AI · AIC-97

Build AI Multi-Agent with Claude Code

Build AI Multi-Agent with Claude Code is an advanced course in directing a team of AI agents in Claude Code, from parallel subagents and specialty agents with their own skills and MCP servers to orchestration, memory, permissions and hooks. It suits developers and tech leads who already use Claude Code, and you leave able to build a web app with an agent team and deploy it to Vercel.

Updated 11 Oct 2026

From 8,010 THB / person 8,900 −10% excl. VAT 7% · group rates available

Corporate training quote Join the waiting list

PDFDownload the course outline

Duration12 hours · 2 days
FormatOnsite / live online
Next roundOn request
CertificateIncluded

Course overview

Many developers already use Claude Code fluently as a coding assistant, one prompt at a time. As the work grows, though, a single agent's context fills up, tasks that could run in parallel are done one after another, and results depend on who writes the best prompt. Claude Code now offers subagents with their own context, skills, MCP, hooks and agent teams, so work can be split across a team of AI agents with clear roles. The real question is how to design that team so it works faster, produces results you can check, and uses no more tokens or permissions than it needs.

This course shows learners how to direct a team of AI agents in Claude Code. It starts with how agents work and how to set up settings.json, then has subagents analyse a codebase in parallel as a swarm, builds specialty agents with Markdown and YAML frontmatter, and binds skills and MCP servers to individual agents. It moves on to the orchestrator-worker pattern, where the leader analyses before delegating, sequential pipelines, context and memory management, and permissions and hooks that act as a quality gate and a cost gate. It closes with a capstone in which a team of specialty agents builds a real business web app and deploys it to Vercel. (2 days, 6 hours per day, 12 hours in total, Advanced level.)

What you’ll gain

Explain how agents and tool calling work, and choose a multi-agent pattern that fits the task and the token budget
Use the built-in subagents in parallel as a swarm and merge their results into one report
Build specialty agents in .claude/agents with their own tools, model, skills and MCP servers
Write skills and install MCP servers at the right scope, then bind them to specific agents
Design an orchestrator-worker setup, write delegation prompts and track work through a task list
Chain agents into a sequential pipeline and manage context and memory across sessions
Set permissions and hooks as a quality gate and a cost gate before letting agents run on their own
Use a team of agents to build a real business web app and deploy it to Vercel with a pre-flight checklist

Who this course is for

Software and full-stack developers who already use Claude Code and want to scale up to a team of agents
Tech leads and solution architects who design AI agent workflows for their team
AI engineers and automation engineers who build multi-step agent systems
DevOps and platform engineers who look after agent permissions, hooks and costs in the organisation
Anyone who has taken Claude Code Roadmap or used an AI coding tool and wants to move to multi-agent work

Prerequisites

Experience with Claude Code or another AI coding tool, and the ability to write clear prompts
Comfortable with the terminal, Git and GitHub, and able to read and write basic JSON
Able to read web app code such as JavaScript or TypeScript to check what the agents produce
Your own Claude account on a plan that includes Claude Code, or an API key, plus a free Vercel account
A laptop that can run Node.js, VS Code and Git, with permission to install software

Curriculum

Course Details

This course focuses on building and directing a team of AI agents in Claude Code. It runs for 2 days, 6 hours per day (12 hours in total, 09:00-16:00), as lectures with labs and workshops on a sample repository and a business web app brief. Advanced level. Learners should already use Claude Code or another AI coding tool, write good prompts, and be comfortable with the terminal, Git, GitHub and basic JSON. Learners use a personal or company Claude account on a Pro, Max, Team or Enterprise plan,

or their own API key, plus a free Vercel account; the institute does not provide accounts or subscriptions. The course builds on Claude Code Roadmap, which covers Claude Code broadly and touches on subagents only briefly. Here the focus is multi-agent work alone: subagents, specialty agents, per-agent skills and MCP, orchestration, agent teams, pipelines, memory, permissions and hooks. For Claude Code fundamentals, take Claude Code Roadmap first. Claude Code features change quickly and agent teams are still experimental, so the content follows the latest version on the training day.

Day 1 Building an Agent Team: Subagents, Skills and MCP

Section 1: How AI Agents Work as a Team

How an agent differs from a chatbot, and how tool calling lets Claude Code read files, edit code and run commands
Multi-agent patterns in Claude Code: subagents, background subagents and agent teams
Each agent's context window, and why separating context makes large tasks more accurate
The token cost of an agent team, and how to decide when a task is worth splitting across agents

Section 2: Lab: Setting Up the Environment for an Agent Team

Terminal, VS Code, Git, Node.js, and reading and writing JSON and environment variables
Install Claude Code as the CLI or desktop app, then check it with claude --version and claude doctor
User and project settings.json, and the settings that affect agents
Lab: set up a sample project and check /agents, /context and /usage before starting

Section 3: Workshop: A Swarm of Parallel Subagents

The built-in Explore, Plan and general-purpose subagents, each with its own context
Have the leader split the work and launch several subagents at once, compared with working step by step
Track background subagents with /tasks and merge their results into one conclusion when they disagree
Workshop: one prompt makes the leader launch parallel subagents to analyse a codebase and combine the reports

Section 4: Lab: Specialty Agents with Markdown and YAML

CLAUDE.md as the team's shared rules, with agent files in .claude/agents or ~/.claude/agents
Have Claude generate an agent file from a prompt, then tune name, description, tools and model per agent
Invoke agents through automatic delegation, @-mentions or claude --agent
Lab: build a Researcher agent that gathers information and summarises it with sources

Section 5: Skills: Task Knowledge Agents Can Pick Up

A skill is a folder in .claude/skills with a SKILL.md file and supporting files
SKILL.md structure: frontmatter, a description that triggers it for the right task, and step-by-step instructions
Use cases, and preloading skills into a subagent through the skills field
Lab: write a report-standard skill and bind it to the Researcher agent so it is always used

Section 6: Lab: MCP Servers for Individual Agents

stdio and HTTP transports (SSE is deprecated), and installing through npx, Docker or a remote URL
The local, project (.mcp.json) and user scopes, and which to choose when working as a team
Bind an MCP server to one subagent with the mcpServers field and limit the tools it can use
Lab: let the Researcher agent use MCP to search external sources without giving that access to other agents

Day 2 Orchestration, Guardrails and Capstone

Section 7: Orchestrator-Worker and Leader-first

The orchestrator-worker pattern: the leader analyses the brief first, then hands work to workers
Delegation prompts: goal, scope, files, output format and a definition of done
Effort scaling: the number of agents and the effort level that fit the task, and the leader's task list
Lab: have the leader analyse a new feature and break it into subtasks with prompts for the workers

Section 8: Workshop: A Frontend, Backend and QA Team

Turn on agent teams (an experimental feature) and how they differ from subagents that report back to the leader
The team lead builds a shared task list so teammates claim work, message each other and own separate files
Workshop: a frontend, backend and QA team builds one feature through the task list

Section 9: Workshop: Sequential Workflows as a Pipeline

Which tasks must run in order, and when running in parallel costs more than it saves
Chain subagents into a pipeline through spec files, or use dependent tasks in agent teams
Workshop: a pipeline that analyses requirements, designs, writes code and reviews it

Section 10: Context Management and Persistent Memory

Organisation, user, project and CLAUDE.local.md instruction files, plus auto memory
Subagent memory at user, project and local scope for remembering across sessions
Isolate heavy work in subagents that send only a summary back to the leader, and use /compact and /clear
Lab: have a Reviewer agent remember the project's common mistakes across sessions

Section 11: Workshop: Permissions, Hooks, a Quality Gate and a Cost Gate

allow, ask and deny permissions in settings.json, and keeping agents away from .env files and secrets
Limit each agent with tools, disallowedTools, permissionMode and maxTurns
Gate logic: stop conditions and the points where a person must approve before work continues
Hooks such as PreToolUse, SubagentStop and TaskCompleted that intercept and block dangerous commands
Workshop: a quality gate that will not close a task until tests pass, and a cost gate that caps turns and token spend

Section 12: Capstone: An Agent Team Builds and Deploys a Web App

The leader analyses a business brief and writes a shared spec that every agent works to
A team of Planner, Competitive Research, Full-stack Developer, Writer and QA/Reviewer agents
Track work through the task list, merge results with the synthesize pattern, and check diffs and tests before accepting
Deploy to Vercel with the Vercel CLI or Vercel MCP and set environment variables
A pre-flight checklist before running agents on their own, then present the work and a plan for real use

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

Join the waiting list Ask about rounds

For organisations — in-house / private

Tailor the content to your team’s tools and projects
Your dates, at your office or live online
Quotation with tax ID for procurement

Corporate training quote

Instructors

Samit KoyomFounder & CEO, IT Genius Engineering

Frequently asked questions

How does this course differ from Claude Code Roadmap?

Claude Code Roadmap covers Claude Code broadly over 30 hours, from the basics through to software development work, and touches on subagents only briefly. This course is the multi-agent specialisation: swarms of subagents, specialty agents, per-agent skills and MCP, the orchestrator-worker pattern, agent teams, pipelines, memory, permissions and hooks. If you are not yet comfortable with Claude Code, take Claude Code Roadmap first.

Which accounts do I need, and does the institute provide them?

The institute does not provide accounts or subscriptions. You need your own or a company Claude account on a plan that includes Claude Code, which means Pro, Max, Team or Enterprise, or an API key through the Claude Console (the Free plan does not include Claude Code). You also need a GitHub account and a free Vercel account, with Node.js, VS Code and Git installed before the training day. How much you can use depends on your plan, and multi-agent work uses more tokens than a single agent.

Why is it Advanced level, and what do I need to know first?

The course does not teach Claude Code basics. You should already use Claude Code or another AI coding tool, write clear prompts, work with the terminal, Git and GitHub, and read and write basic JSON, because every lab involves editing settings files, writing agent files and checking the code the agents produce yourself.

How many tokens does an agent team use, and how do I keep costs under control?

Every agent has its own context, so token use grows with the number of agents, and agent teams in particular use far more than a single session. The course shows you how to pick a pattern that fits the task, use smaller models for simple work, cap turns with maxTurns, check usage with /usage, and build a cost gate with hooks that stops work before it goes over budget.

Is it safe to let agents run on their own?

The course puts guardrails at every step: allow, ask and deny permissions in settings.json, keeping agents away from .env files and secrets, limiting each agent's tools and permissions, hooks that intercept and block dangerous commands, points where a person must approve before work continues, token budgets, and checking every diff, test and piece of content an agent produces before accepting it. A pre-flight checklist covers all of this before any autonomous run.

Agent teams are experimental, so will the content stay current?

Claude Code features change quickly, and agent teams are still an experimental feature that you turn on yourself. The instructor updates the content and labs to match the latest version on the training day. The core ideas, such as separating context, leader-first analysis, delegation prompts, task lists and guardrails, still apply when command names or the interface change.

Articles are published in Thai.