Short answerA multi-agent system is an architecture where multiple autonomous AI agents — each with its own role, memory, and tools — communicate and coordinate to accomplish tasks that no single agent could solve alone. Each agent specializes in one domain, and a coordinator or orchestrator routes work, resolves conflicts, and aggregates results.
In depth
Multi-agent systems split a complex goal into sub-goals and assign each to a specialized agent. Rather than prompting one general-purpose LLM to do everything, you build a small team — a planner, a researcher, a writer, a verifier — and let them pass artifacts between each other. The pattern mirrors how human companies organize: specialization beats generalization once a task crosses a certain complexity threshold. Technically, a multi-agent system has three load-bearing components. First, agents: each is typically an LLM with a custom system prompt, a scoped tool set, and its own memory. Second, a communication layer: agents pass structured messages (JSON, text, or function-call shapes) that another agent can read and act on. Third, a coordinator: sometimes called a supervisor, orchestrator, or router — it decides which agent runs next, passes context between them, and handles failures. Anthropic's 2024 research on 'orchestrator-worker' patterns and OpenAI's Swarm / Assistants API both formalize these roles. Why does this work better than a single mega-prompt? Context windows. Even with Claude 4.5's 200K or Gemini's 1M+ tokens, a single agent loaded with every tool, document, and instruction for a large task starts producing degraded outputs (needle-in-a-haystack failure, instruction drift). Splitting responsibilities into 5-10 smaller agents — each with a focused prompt and narrower tool set — produces more reliable results, parallelizes naturally, and makes failures easier to debug because you can see exactly which agent failed. Typical patterns include: (1) hierarchical, where a manager agent delegates to workers; (2) peer-to-peer, where agents of equal status negotiate; (3) pipeline, where agents are chained like Unix pipes; (4) market-based, where agents bid on tasks. Most production systems today use the hierarchical pattern because it matches how humans organize work and because debugging a tree is easier than debugging a graph. Tycoon uses the hierarchical pattern: the founder talks only to Tycoon Agent (the Manager), who routes an Outcome Task to an accountable Lead. The Lead assigns bounded child Tasks to specialists. Each specialist receives only the minimum scoped Company Brain context needed for that contribution; no Agent owns private Team memory or a peer-chat channel. Evidence returns through the Task graph to the Lead and Tycoon Agent, so the founder never has to manage the internal handoffs. This is the same broad orchestrator-worker family used by AutoGen (Microsoft), CrewAI (open-source), and LangGraph (LangChain's graph-based orchestration framework), but wrapped in a business-operator interface rather than a developer framework.
Examples
- Tycoon — Tycoon Agent (Manager) coordinates AI CMO, CTO, COO, CFO; each specialized agent runs its functional area while Tycoon Agent handles cross-functional planning and founder communication
- Anthropic's agentic coding demos — a planner agent breaks down a coding task, a coder agent writes the implementation, a reviewer agent checks the output
- AutoGen (Microsoft Research) — framework for building conversational multi-agent systems where agents can include humans, tools, and other LLMs
- CrewAI — open-source framework where you define a 'crew' of agents with roles, goals, and tools; a manager agent orchestrates them
- LangGraph (LangChain) — graph-based orchestration where each node is an agent and edges define the flow of work
- OpenAI Swarm / Assistants API — lightweight handoff patterns between specialized GPT-based agents
- Devin-style autonomous coding agents — a planner, a coder, a test-runner, and a reviewer collaborating on software engineering tasks