How to Build an AI Team (Coordinator + Specialists)

The 2026 accounts of working AI teams overlap enough to assemble a pattern from. Grok Bot's tutorials teach the chief-of-staff convention: one pinned coordinator Bot, specialists per lane. Allie K Miller says she runs 34 agents under one chief-of-staff agent and six functional directors, managing by escalation rather than supervision. Tom Blomfield's loop model contributes the other half: quality gates, a learning step, and humans providing direction at the edges. On the build side, where this site works, the coordinator-and-specialists architecture goes by a plainer name: a graph whose nodes are loops. Combining those overlapping accounts is our editorial synthesis, and it yields five parts: coordinator, specialists, shared memory, quality gates, human at the edges.

The overlap across independent accounts is the evidence this page rests on, and the most common early mistake we see is building the org chart before there is a single working agent. What follows is the build order we use, from running a fleet in production.

The Five Parts

• Specialists. One agent, one job, one written contract: what it does, what done means, what it must never do, when it stops and asks. The contract is the difference between a specialist and a prompt.
• A coordinator. Routes incoming work to specialists, holds cross-job context, escalates to you. In Grok Bot this is the chief-of-staff Bot; in Miller's telling, her chief-of-staff agent fields everything and delegates; in a built system it is an orchestrator node.
• Shared memory. Artifacts every agent reads before working and writes after: findings, decisions, state. This is what makes the team more than its members; agent memory is the deep dive.
• Quality gates. An executable check, or an adversarial reviewer that is not the producing agent, between output and the world. Blomfield's recommendation: the gate can often be a second adversarial model rather than a person. Ours: self-evaluation is a trap.
• The human edge. You set direction, decide what deserves to exist, and take escalations. Across the reviewed accounts, judgment stays at defined human boundaries, though the mechanism differs: Grok Bot uses approvals, Miller describes escalation-only management, and built loops use executable gates with escalation rules.

The Build Order We Use

1. Hire one specialist and make it boring. One recurring job, contracted, scheduled, gated. Do not proceed until it has run for a while without surprising you; a team of flaky agents is flakiness with an org chart. This unit is loop engineering, and it is deliberately unglamorous.
2. Give the team its memory before its second member. The shared store is cheapest to establish early, and it is what makes each new specialist cheaper than the last, because agent two starts with everything agent one learned.
3. Add specialists one job at a time. The temptation is to design the whole company of agents up front. Resist it: every agent you add is a contract to maintain and a new way for state to leak, so each one should be pulled into existence by a real job, not pushed by the org-chart fantasy. (Dylan Harris's graph-engineering formulation of the same rule: the goal is the smallest graph that improves quality.)
4. Appoint the coordinator last. Until several specialists genuinely need routing between them, you are the chief of staff, and you are better at it than an agent with nothing to coordinate. When the routing load is real, add the coordinator as its own contracted node, and give it the narrowest job that solves the actual problem: routing and escalation, not doing.
5. Watch the team, not just the work. A notable role in Miller's setup is an agent whose only job is watching the other agents for friction and missing access. The build-side equivalent is instrumentation: run logs, failure counts, and a periodic review of where agents got stuck. Teams degrade quietly; something has to be looking.

Five Failure Modes

• Coordinator-first. The most common. An orchestrator with no working specialists is cost plus a new failure surface, producing nothing.
• Role-titled agents without contracts. Agents named for human roles instead of contracted for jobs. A "Head of Marketing" agent is a prompt; a specialist that drafts, gates, and ships one content pipeline is an employee. (The conference-talk version of this lesson: Subbiah Sethuraman and Abhilash Asokan of ZS Associates killed their multi-agent pipeline after building it to mirror the stages of a human analyst's workflow; they report context lost at handoffs, deterministic work handed to an LLM, and no agent owning the end-to-end conclusion.)
• Chatty coordination. If agents coordinate through long conversations rather than structured handoffs and shared artifacts, token spend scales with team size and coherence falls. This is also the documented failure pattern behind hosted-product limit burn.
• No gate between team and world. A team that ships whatever its members produce multiplies mistakes instead of catching them. Our rule is to require a gate at team scale, because mistakes now compound across agents.
• Human in the middle instead of at the edge. If every task routes through your approval, you built a very expensive to-do list. Approvals belong on consequential actions; the rest belongs behind verifiers.

The Managed and Built Versions

If you want this shape without infrastructure, Grok Bot productizes the coordinator, specialists, shared context, and approval surface, with the trade-offs our buy-vs-build sort covers, and OpenBot open-sources the surface for self-hosters. A built system can implement the full five-part pattern, including executable gates, assembled from loops, a graph, shared artifacts, and gates. In our judgment the choice between them is about control and cost, not about which side has the working architecture.

The unit under every version of this, the one contracted specialist that runs on schedule and ships behind a gate, is what the Loop Engineering course builds. Hire your first agent there; the team follows.

Related Content

• Graph Engineering Guide (2026) - The architecture under the team: nodes, edges, shared state, and when coordination pays.
• Loop Engineering: Stop Writing Prompts, Start Writing Verifiers - Specialist number one, end to end.
• How to Become an AI-Native Company - The company-scale sequencing: which functions get a team first, and what breaks.
• Grok Bot: How to Use It - The managed version of this pattern, with the chief-of-staff convention and its limits problem.
• Who Owns Your AI Agents - Credentials, autonomy ladders, and offboarding for a team of agents with real access.
• How to Evaluate AI Agents - The gates: why self-evaluation fails and what to build instead.

Join AI Builder Club