Agent topologies
Topology is the shape of an agent system. It shows where decisions are made, what holds control, where tools and sub-agents sit, and how information moves through the system. Topology is what turns a collection of capabilities into an operating design.
Dense reasoning core radiating to satellite specialists. Orchestrator + specialists.
N parallel solvers explore sampled reasoning paths; a majority-vote aggregator collapses them to one consistent answer.
N agents in a fully-connected mesh iterate arguments and counter-arguments each round until consensus. Every agent sees every other's proposal per round.
A side-agent rides beside the main agent chain, tapping events without being on the primary path. Typical memory-harvesting pattern.
A read-only meta-agent sits above the main agent, observing actions and providing advisory feedback. Main agent decides whether to act.
A coordinator spawns N ephemeral workers, collects outputs, terminates them. Workers are short-lived and non-communicating.
N judge-agents independently evaluate a proposal; a verdict aggregator applies a quorum rule (majority / unanimity / weighted).
Producer emits, critic rebuts, arbiter (optional) resolves. Loops until convergence or timeout. Widely used in code-review + reasoning-verification.
Scalarity's signature control topology. Brain classifies intent as a structured tool_call (the only LLM step). One dedicated confirmation turn gates the transition, human-in-the-loop or programmatic. Dispatch is 100% deterministic code with the safety gate embedded inside, no LLM in the write path. Capability grows by adding routes, not by branching code.
Fan-out across data partitions in parallel; a reduce node aggregates the outputs. Built-in parallelism.
Classify intent and route to exactly one of N branches: not all. A cheap triage front-door, distinct from Hub & Spoke.
A planner recursively spawns sub-planners and workers: open-ended task breakdown where scope is unknown upfront.
A shared workspace agents read and write opportunistically, without direct coupling. No fixed control flow.
One agent reads stage-specific instructions from numbered folders; each stage produces plain-text output that seeds the next. Filesystem is the orchestrator; no multi-agent framework required. Human review gates sit between stages.
Named role-agents (PM, architect, engineer) coordinate through a shared workspace of structured artefacts (PRD, design, tasks, code) written as files. Each downstream agent consumes the previous agent’s artefact from the filesystem.
A single-agent workflow driven by a folder tree (.specify/) plus a fixed phase sequence: constitution, specify, plan, tasks, implement. Each phase reads and writes markdown artefacts in its own directory; the filesystem carries state between commands.
Named role-stages pass a growing artefact along a strict linear pipeline. Each stage owns one phase (analyst → architect → engineer → QA), reads what the previous stage produced, and adds its own contribution before handing off. The SOP is the topology.
A pipeline whose stages are role-agents, not tasks. The same message flows through role-typed handlers (product owner, architect, coder), each transforming it. Distinct from assembly-line by making the role identity the coordination unit rather than the sequence.
Multiple autonomous agents with persistent memory, planning and reflection sharing an environment, forming and updating relationships without a coordinator. Emergent coordination through observation, memory retrieval and self-driven action.
Agents coordinate through a directed graph of message exchanges. Any agent can address any other; the exchange history is the coordination substrate. Reads as a graph, not a chain, because messages fork, reply and cross-cut.
A manager (or moderator) agent runs a shared conversation of N specialist agents, selecting who speaks next based on the transcript. Coordination is centralised at the moderator; the transcript is the shared state.
Two agents adopt paired roles (user + assistant, teacher + student, critic + generator) and iterate through structured dialogue. The dyad’s rules are the topology; a single task can traverse the loop many times.
Reasoning states form a tree the agent expands and evaluates node-by-node, backtracking from dead ends. Search discipline (BFS or DFS) plus a heuristic evaluator select which branch to grow. Distinct from chain-of-thought by choosing between alternative continuations rather than committing to one.
Seeded by · peer-reviewed academic sources Live data view 30 sources
The capability and control patterns that cross-cut every topology: what an agent can do, and how its control flow is governed. From internal research (unvalidated; sources cited in the originals).
Memory-store nodes inject scoped context at designated graph positions without coupling agent implementations.
Short-term, long-term, episodic and semantic stores persisted across runs; procedural (skills) emerging as a 4th type.
A single agent critiques and revises its own output: self-contained cousin of the Supervisor Loop, no separate evaluator.
Tracing and eval criteria attached to every node: turns an opaque flow into something you can debug and measure.
Human-in-the-loop approval blocks execution until explicit operator confirmation.
Route on a predicate, the single deterministic fork that splits a flow into true/false paths.
Iterate a node with a hard cap on cycles. Prevents runaway revision loops in self-correcting agents.
Re-attempt a failed node with escalating delay. Absorbs transient faults in external tool/API calls.
Halt calls to a failing dependency after a threshold; probe before resuming. Stops cascading failure and wasted spend.
Compensating actions undo committed side effects when a later step fails. Keeps multi-step write workflows consistent.
The shape is the pattern: orbs are sub-agents or steps, lines are control flow
Topology is to an agent what topography is to terrain: it describes the shape. Which parts exist, how they are arranged, and the path information takes through them. Drawn out, a topology is nodes and edges, with a model runtime at the core, sub-agents and capabilities around it, and data moving between them. It is the anatomy reduced to its arrangement.
Show more
Across thirty named patterns the striking thing is how singular most of them are: one agent directing a set of actions, tools or sub-agents. Genuinely multi-agent designs, where several agents work in tandem across a process, are still the minority, and are the more likely direction of travel. Sidecar is a useful middle case, where a smaller agent rides beside the main chain and taps events to harvest memory or coach, without sitting on the primary path or altering the flow. Twenty-three of the thirty cite a Tier-1 source, the canonical shapes seeded by peer-reviewed multi-agent research: OFA-MAS (WWW 2026), MASS (Google Research and Cambridge), MASEval (ACL 2026) and REALM-Bench.
What is an agent topology?
A topology is the shape of a multi-agent system: which agent talks to which, and who decides what happens next. The usual shapes are one orchestrator with specialists under it, a fan-out to parallel workers, and a group that argues its way to one answer. The shape decides how the system fails as much as how it works.
What is a hub-and-spoke agent topology?
One orchestrator in the middle, specialist sub-agents around it. The orchestrator holds the plan and hands each sub-task to whichever agent is suited to it. It is the most common production shape because there is one place to look when something goes wrong.
What is map-reduce for agents?
Split one task across several agents running at the same time, then merge their answers into one. It suits work that divides cleanly, like summarising 100 documents or grading 50 answers. It breaks down when the sub-tasks need to know what the others found.
What is a debate or ensemble of agents?
Several agents answer the same question independently, then a judge picks or merges the answers. Disagreement is the point: separate attempts catch each other's mistakes before anything is committed. It costs several times the tokens of a single pass, so it is used on high-value work rather than at scale.
What is an agent swarm?
Agents that self-organise with no central controller. Each follows local rules and the coordination emerges from their interaction rather than from a plan someone wrote. It scales well in theory and is hard to debug in practice, which is why it is rare in production.
Do I need more than one agent?
Usually not. A single agent with good tools handles most tasks, and Anthropic recommends starting with the simplest thing that works and adding agents only when it stops working (Anthropic). Multiple agents earn their cost when sub-tasks can genuinely run in parallel or need separate context.