Agent Topology Follows Task, Not Template
Org-chart agent systems import human coordination limits into machines that don't have them. Let the task emit the graph instead.
Everyone is building org-chart agents, and the org chart is the bug.
Planner → Executor → Critic. Manager → Worker → Validator. Trees of LLMs wired into patterns that look suspiciously like the company structure on a whiteboard.
It feels right because it mirrors how we organize. But humans invented hierarchy to compensate for being human: slow sequential thinking, limited bandwidth, memory that doesn’t transfer between heads. Machines have none of these constraints. Wire LLMs into a fixed hierarchy and you aren’t solving a coordination problem—you’re importing one.
The 2025–2026 papers have been converging on this conclusion from different angles. Once you see the pattern, it is hard to unsee.
The evidence: fixed shapes plateau
The empirical record keeps saying the same thing.
MacNet (ICLR 2025) scaled to a thousand agents and found that irregular topologies beat regular ones—chains, stars, and trees plateaued early. Kim et al. (2025) measured 17× error amplification in uncoordinated groups, with performance swinging ±80% on architecture alone.
Graph of Thoughts (AAAI 2024) delivered a 62% quality improvement over Tree of Thoughts at 31% lower cost. Shen et al. (EMNLP 2025) showed query-adaptive topologies reaching 91.38% on MMLU and GSM8K, beating every fixed shape.
The field’s own trajectory—Chain of Thought → Tree of Thoughts → Graph of Thoughts—points the same way. The next step isn’t another fixed structure. It’s no fixed structure at all.
The shift: topology as output
Here’s the move: topology stops being an input to the system and becomes an output of it.
Static systems hardcode human assumptions about how agents should interact; dynamic systems let the task dictate the shape. A cheap LLM call—$0.001, 200ms—reads the problem and emits the graph: which models to call, in what order, with what parallelism, with back-edges where needed.
# Human designs topology
topology = org_chart(human_team)
result = topology.execute(task)
# Model designs topology
topology = llm("emit graph for this task", task, available_agents)
result = topology.execute()
Sometimes the model emits a chain (a data pipeline). Sometimes a parallel fan-out (a brainstorm). Sometimes a loop with back-edges (design → code → critique → redesign). Sometimes a hierarchy—because the task demands it, not because your framework ships it as the default.
The graph is chosen from a design space you define. That is the difference between dynamic topology and chaos.
The design surface: what you still build
Dynamic topology doesn’t eliminate design. It moves design one level up.
You still design the agent pool. Heterogeneous beats homogeneous: X-MAS (2025) reports +47% on AIME from mixing reasoners and chatbots instead of stacking identical models. You still design the edge vocabulary: what can flow between nodes, which back-edges are allowed, whether agents share state or only messages. You still design the density default: moderate sparsity with small-world structure—local clustering plus a few long-range shortcuts—is the strongest known inductive bias across Shen et al. and Wang et al.. And you still design the objective and constraints: whether the solver optimizes cost, latency, quality, or consistency, and what bounds it must respect—max depth, max cost per query, safety rules.
What’s still open: the right task-to-objective mapping, when to regenerate the graph versus reuse a cached one, whether topology should change within a single execution, how dynamic graphs degrade under adversarial agents, and what theory governs scaling. The research is early. Treat the rules above as starting defaults, not a finished system.
This is more work than hardcoding a pipeline—much more—and that schlep is where the advantage is. Everyone else is wiring graphs by hand because the alternative is harder.
Compiler writers don’t write machine code; they design the rules that generate it. Agent builders should do the same, and be honest about which rules we don’t yet have.
Stop wiring, start compiling
Static agent topologies are training wheels on a bicycle that never needed them.
The best agent system is not the one with the cleanest org chart. It is the one you cannot draw, because it vanishes into the problem it solves.
Stop wiring. Start compiling.
If you’re building agent compilers: zguo0525@berkeley.edu · @Zhen4good
— Gavin Guo, April 2026