Han Xin Could Command an Army of Any Size. You’re Still Stuck at One Hundred Thousand.

AI hasn’t flattened organizations. AI is simply the first technology to put a precise price on “protocol cost.”

I

“The more, the better.” When Han Xin said this, Liu Bang laughed.

It was 196 BC. Han Xin had already been demoted from King of Qi to King of Chu, and then to Marquis of Huaiyin, effectively under house arrest in Chang’an. During a casual conversation, Liu Bang asked how many troops he himself could command. Han Xin replied: one hundred thousand. Liu Bang then asked how many Han Xin could command. Han Xin answered, quite casually: the more, the better.

After laughing, Liu Bang countered with a devastating question: if you’re so good at commanding troops, how did I manage to capture you? Han Xin sobered up slightly and added: “Your Majesty cannot command soldiers, but excels at commanding generals. This is why Xin was captured by Your Majesty.”[1]

This exchange was recorded in the Records of the Grand Historian and has circulated for over two millennia. But people usually remember only the four words “the more, the better,” rarely noticing one thing: Han Xin was not boasting.

Rewind four years. 202 BC, Gaixia. Han Xin commanded a coalition of roughly 600,000 troops, including about 300,000 Han soldiers directly under his control. That same year, facing him was Xiang Yu with roughly 100,000 Chu troops. Looking back at Xiang Yu’s most glorious battles: at the Battle of Julu, he led 50,000 to rout 400,000 Qin troops; at the Battle of Pengcheng, he led 30,000 to defeat 560,000 Han troops. Xiang Yu’s ability to win against superior numbers was unmatched in history, yet in his entire life he never personally commanded more than 100,000 troops.[2]

It wasn’t that Xiang Yu couldn’t fight. It was that Xiang Yu couldn’t command.

Same era, same cold weapons, same peasant conscripts — yet the two men’s “span of control” was worlds apart. Today, everyone working on AI stands at the same fork in the road: do you want to be Han Xin, or Xiang Yu? Most teams unconsciously choose Xiang Yu.

II

Han Xin could hold 300,000 men in his hand not because he remembered every soldier’s name. He relied on a protocol that had been maturing for about 1,500 years.

The Han army’s structure was roughly this: five men made a wu; two wu made a shi; five shi made a dui; two dui made a tun; five tun made a qu; two qu made a bu. Above bu came battalions and armies. At every level, a commander only needed to watch the signals of 5 to 10 subordinates. The entire 300,000-man force was sliced into a tree about 7 levels deep, with each node watching only its own handful of children.

The signal flags themselves were a protocol thought through long ago. The Art of War puts it in one sentence: “When words cannot be heard, make gongs and drums; when sights cannot be seen, make banners and flags. Night battles rely on gongs and drums; day battles rely on banners and flags.” Watch the flags by day, listen to the drums by night. Front camp red, rear camp black, center camp yellow, left camp green, right camp white — the rising and falling of the five colored flags corresponded to a fixed set of commands. To order the front camp to attack, the commander-in-chief didn’t need to shout or write a dispatch; he simply had a messenger raise the red flag. One bit of information, transmitted by one flag.[3]

This was the densest compression protocol cold-weapon warfare could devise. Xiang Yu clearly knew this system, but he didn’t like using it. The Records of the Grand Historian: Biography of Xiang Yu repeatedly records “the Hegemon-King personally led” and “the Hegemon-King, enraged, personally led thirty thousand men.” What he loved was being at the front lines, cutting down enemies himself. The number of troops one man can directly see and personally command is roughly on the order of one hundred thousand. Any more, and the flags can’t be seen, the drums can’t be heard — he simply can’t manage it.

Jump forward two thousand years. 1804, Paris. Napoleon did something structurally almost identical to Han Xin. He re-sliced the French army into a new unit called the corps. Each corps held roughly 20,000 to 40,000 men, internally self-contained with infantry, cavalry, artillery, staff officers, and a supply train that could sustain several days of marching. A corps was a miniature army, capable of independent combat, independent logistics, independent decision-making. The Napoleon Series archives contain a crucial line about this: “change direction at once and concentrate anywhere within 24 hours.” In any direction, within 24 hours, the various corps could converge for a combined assault.[4]

Supporting this was another severely underrated figure, Louis-Alexandre Berthier. He served as Napoleon’s chief of staff for 18 years; soldiers privately called him “Napoleon’s wife.” Berthier himself almost never fought battles. What he did was extremely focused: translating Napoleon’s grand, abstract, sometimes capricious strategic intentions into specific marching orders, supply lists, and rendezvous points that each corps commander could directly execute. The French military’s 2024 internal large model, designed specifically for staff officers, is literally named Berthier. The naming is a hidden joke, because the chief of staff’s job has always been orchestration.[5]

Jump forward another 150-odd years. 1956. Harvard psychologist George Miller published a paper in Psychological Review titled The Magical Number Seven, Plus or Minus Two. He conducted a series of experiments and reached a very straightforward conclusion: the number of “chunks” a human can hold in working memory is roughly 7, plus or minus 2. This paper was later cited to the point of cliché, directly spawning Amazon’s “two-pizza team” principle and various management dogmas about “spans of 5 to 9.”[6]

But all these stories answer the same question: how much information must you transmit for a subordinate to execute correctly? The standard name for this problem is “span of control,” but people widely misunderstand it. Span of control is not a bandwidth problem — you can shout and make ten thousand people hear you. It is a protocol cost problem: how many bits must you transmit for a subordinate to make no mistakes? The vaguer the language, the more bits needed; the more refined the protocol, the fewer bits needed. Cold-weapon battlefields had zero bandwidth, yet that one bit from a flag was enough to command 300,000 men. Today’s computers have near-infinite bandwidth, yet because we use the vaguest protocol — natural language — we can’t even manage five agents.

III

By all rights, the AI era should be paradise for organizational flattening. Two agents passing a JSON message, 50 milliseconds latency, near-infinite bandwidth. Flattening Han Xin’s 7-level command tree into a single layer of 300,000 leaf nodes presents no problem from a communications perspective.

But reality is the exact opposite.

Since the second half of 2024, virtually every team building agents has been repeating the same awkward discovery: if you have five GPT-4s collaborate, they usually lose to a single GPT-5. All the theoretical advantages of multi-agent — parallelism, division of labor, specialization — evaporate when running benchmarks.

Anthropic’s 2025 report on their multi-agent research system quantified this awkwardness for the first time. Their internal orchestrator-worker architecture did indeed score 90.2% on research evaluations, beating single-agent Opus 4. But the cost was staggering: a single agent used roughly 4 times the tokens of a normal conversation, while the multi-agent system used 15 times. An even more painful sentence appeared in the same blog post: “token usage alone explains 80% of performance variance.” In their internal data, token usage alone could explain 80% of the performance difference.[7]

Translated: the reason multi-agent beats single-agent is not mainly that the division of labor is smarter. It’s that multi-agent is allowed to burn 15 times the tokens. Give a single agent the same token budget, and the gap probably disappears.

A more direct counterexample comes from Cognition, the team behind Devin. In 2024 they published a blog post titled Don’t Build Multi-Agents. The core thesis was just one sentence: once an agent needs to run for a long time and maintain consistency, you must do everything possible to prevent “compounding errors,” because multiple agents each make a pile of implicit decisions, these decisions conflict with each other, and the final result is a chaotic mess.[8]

Even more revealing was the follow-up ten months later. In April 2026, Walden Yan wrote another post, retitled Multi-Agents: What’s Actually Working. It was a very honest U-shaped regression. They added multi-agent back in, but only one structure: multiple agents could contribute intelligence and share reasoning, but write operations had to be single-threaded, and the final order could only come from one agent.[9]

Translate that sentence into Napoleonic-era language, and it is almost word-for-word identical: multiple staff officers may plan, but only the commander-in-chief may issue orders.

So where exactly does the failure of five agents lie?

Not in the models. Models get smarter every year. Not in bandwidth either — passing a structured message between two GPUs costs almost nothing. The problem is the protocol.

The vast majority of multi-agent frameworks — LangChain, AutoGen, CrewAI, early MetaGPT — use natural language as the “protocol” for communication between agents. You write a prompt for Agent A; A thinks for a while, then tells Agent B in a chunk of natural language; B then interprets what A said, forms its own judgment, and tells C. This is equivalent to removing the signal flags between the wu-leader and shi-leader in Han Xin’s army and having them pass orders via chat instead.

Worse, with each additional agent, errors don’t add — they multiply. An accidental ambiguity in one prompt is treated as fact by the next agent, then as a premise by the agent after that. Three steps later, you’ve drifted to the moon. Cognition named this phenomenon “compounding errors.” And it is fundamentally the same thing as the ceiling between Han Xin and Xiang Yu: once a protocol becomes vague enough, organizational scale and error cost explode in tandem.

So five GPT-4s losing to one GPT-5 is not because the models aren’t strong enough. It’s because five agents communicating via natural language wipe out whatever signal-to-noise ratio the models could have given you.

IV

So how do you truly organize AI like Han Xin and Napoleon? At least four things can be directly lifted from this century-plus of military organizational history.

First: Turn agent-to-agent communication into a structured protocol.

Han Xin’s gongs, drums, and signal flags were a structured protocol. When a red flag goes up, it can only be interpreted as one command — no ambiguity, no extra words, no “maybe this is what it means.” Every wu-leader seeing that flag produces a mechanical, reproducible response. The entire 300,000-man army, in that moment, moves in unison in one direction.

When OpenAI launched function calling in mid-2023, and Anthropic followed with tool use, they were essentially importing this system into LLMs. They require the model’s output to strictly conform to a JSON schema — fields, types, required items, not one may be wrong. Pydantic AI, Instructor, and BAML are all doing the same thing from different angles: forcing the model to squeeze language into structure.[10]

The first true/false question for building a multi-agent system is this: do your agents pass JSON or natural language to each other? If it’s the latter, you’re not building distributed intelligence. You’re building distributed hallucination.

Second: Give each agent a long enough block of autonomous work time.

The essence of Napoleon’s corps system lies in that line: “change direction at once and concentrate anywhere within 24 hours.” Once a corps commander receives a mission, for the next 24 to 72 hours he needs no further orders. With his own infantry, cavalry, artillery, and a pocket map, he solves the problems before him himself. This autonomy is not laissez-faire; it is freedom underwritten by protocol — the protocol tells him which city to head toward, under what conditions to halt, under what conditions to rendezvous, and all tactical decisions in between are his own.

In today’s AI, the vehicle for this is long context plus agent harness. By 2026, Claude Mythos’s context window had expanded to 1M tokens; GPT-5 is at a similar scale. The harnesses used by Devin, Cursor, and Claude Code all allow an agent, after receiving a task, to decide its own next tool call, running dozens of steps without human intervention. In their harness engineering blog post, Anthropic emphasized that context management and compaction are the core of making an agent run long.[10]

Many teams do the opposite at this step. Every two steps, the orchestrator clips the context, a human reviews once, and the agent restarts. It looks safe, but in practice it turns the corps system into 18th-century centralized command. The commander-in-chief never stops shouting at the front lines; no corps can ever move beyond two kilometers of his sight. The number of troops that can be managed naturally falls back to one hundred thousand.

Third: Strictly separate the general staff from the commander.

Berthier was an underrated genius of his era precisely because what he did was extremely narrow. He took Napoleon’s abstract intention — “I want to force Austria to the negotiating table within two weeks” — and broke it down into specific marching orders, supply lists, and rendezvous points for each corps. He didn’t fight battles. He didn’t make decisions for Napoleon. What he did was closer to translation.

In Anthropic’s multi-agent paper, the role division maps almost word-for-word to the Berthier-Napoleon model: the lead agent does planning and synthesis; 3 to 5 subagents search for materials and run tools in parallel; finally there is a separate citation pass. The lead agent itself almost never touches specific documents; its job is to set direction and read conclusions.

Cognition’s later U-shaped regression exactly confirmed the反面 situation. In early multi-agent frameworks, it was common to have two or three parallel writers simultaneously editing the same code, simultaneously issuing commands, simultaneously making implicit decisions. This is equivalent to an army where five Berthiers are all giving orders at once, each believing himself authoritative. The multi-agent mode Cognition later added back strictly required that multiple agents may advise, but write operations must be single-threaded — restoring Berthier to a single person.

In engineering terms, another implication of this principle is: don’t let the orchestrator overreach into execution. Once your planner agent starts writing code, editing files, or adding database fields itself, you’ve walked back down Xiang Yu’s old path.

Fourth: Put your strongest model in the execution layer, not the scheduling layer.

This is the most counterintuitive point, and also the easiest to get backwards.

Many teams’ first intuition is: since the orchestrator is the brain and subtasks are the limbs, the brain should use the strongest model. So GPT-5 does planning, GPT-4o-mini does execution. The result is that the planner makes beautiful plans every time, while the execution layer — with fields haphazardly filled in by the mini model, skipped steps, misjudged boundary conditions — drags the whole system back to 2023-level performance.

Go back and reread the dialogue between Han Xin and Liu Bang. The crucial line is not “the more, the better.” It’s what follows: “Your Majesty cannot command soldiers, but excels at commanding generals.” Han Xin’s point is that commanding soldiers and commanding generals are two entirely different abilities. Liu Bang’s ability was recognizing talent and delegating authority; he himself was not effective on the front lines. Han Xin could directly grip 300,000 men. Both abilities exist simultaneously, but they are not interchangeable. You cannot replace a good general-commander with a good soldier-commander, nor vice versa.

In AI terms, planner and executor are two different kinds of intelligence. A planner needs to clearly understand task structure and break a goal into steps — this is a relatively low-bandwidth intelligence. An executor needs to precisely operate tools, read code, and edit files in long-context, uncertain environments — this is high-bandwidth intelligence, almost a matter of “feel.”

Map these two types of capability to models, and you’ll discover a朴素 fact: mid-tier models can already do planning well. Models at the GPT-4o and Claude Haiku level have high accuracy for task decomposition and pure tool scheduling. But in the execution layer, a few percentage points of model capability difference gets geometrically amplified over long tasks. So the correct formula is: mid-tier model for scheduling, strong model for execution.

This is also the shared choice of Cursor, Devin, and Claude Code as they reached 2026: one strong agent plus a rich set of tools. The so-called “multi-agent” in these products is more parallelism at the tool level, not multiple model copies at the model level. Cursor’s Agent has a full suite of tools — view, edit, grep, glob, batch, delegation — and Claude Code has a similar list. They may not look like Han Xin’s 300,000 men, but each tool is essentially a highly structured sub-unit that the agent can call repeatedly, and these tools are the true corps.[11]

With these four points stated, you probably see something quite counterintuitive: the best-performing agent products today resemble Han Xin, Berthier, and Napoleon in architecture, not the multi-agent mesh diagrams drawn in papers.

V

Academia and industry are diverging into two paths in their judgment of what agents are.

Academia is still stacking agent counts. On benchmarks like SWE-Bench, AgentBench, and TheAgentCompany, most new papers either propose new multi-agent collaboration patterns, new debate frameworks, or new self-reflection topologies. MetaGPT, ChatDev, and AutoGen have each posted scores a few points higher than single-agent baselines. MetaGPT X once hit 46.67% on SWE-Bench Lite, which at the time was state of the art.[12]

Industry has quietly turned back. Cursor, Claude Code, Devin, v0 — the cohort of products actually making money in 2026 — are almost all single-agent-plus-rich-tools architectures. The 2026 SWE-Bench leader, Claude Mythos Preview, hit 93.9% on SWE-Bench Verified, and it is essentially still a strong single agent.[13] Cognition’s Don’t Build Multi-Agents resonated because the entire industry was quietly choosing sides; they just lacked the courage to write it out.

But the biggest divergence between industry and academia is not in agent count. It is in another thing: on-going training.

A common feature of most academic agent papers is that the model’s weights are frozen. You swap frameworks, swap prompts, swap tools, but the model itself doesn’t change from the day it finished training. This is like turning the French army into a force forever limited to the 1804 manual. No matter how brilliant a Berthier you have, he cannot make this army any better.

Industry is doing the exact opposite. OpenAI released Reinforcement Fine-Tuning in late 2024, allowing you to fine-tune the o-series models on a small dataset with a grader. Its official billing is by training time, not by token — the message is clear: this is not a one-time batch fine-tune; it is meant to be run continuously, over the long term. The three canonical use cases for RFT all revolve around the same thing: turning failures, ambiguities, and pitfalls from the production environment into instincts that the next version of the model will no longer make.[14] This is essentially taking yesterday’s lost battle and turning it into the pocket manual given to new recruits.

Anthropic takes a different path with Claude Code: auto memory and skills. Since v2.1.59, Claude Code automatically accumulates build commands, debugging experience, architectural decisions, and style preferences about your project across sessions. Its mechanism does not modify weights; it maintains a continuously growing retrieval pool at the inference layer.[15] These two paths — RFT baking things into weights, memory hanging them out in context — share the same essential purpose: turning this protocol into next time’s instinct.

The continuous fine-tuning that industry products are rumored to have run for years — Cursor’s reranker and completion models, Replit Agent’s code edits — are all fundamentally doing the same thing. Every failed case that goes live, every diff rejected by a user, every modification rejected in PR review, is automatically collected, graded, and fed back into the next version’s weights. From the outside, each model update is just a patch version bump. From the inside, each round of feedback constitutes a never-ending training loop.

If you connect this with the flattening story from earlier, you’ll find they are two sides of the same coin.

Whether flattening can work is fundamentally equivalent to the question: “Can protocol cost be driven to zero?” Structured JSON has pushed the per-interaction protocol cost down by an order of magnitude, but it is still not zero; every agent, in every task, still needs to re-“understand” the task, re-“judge” boundaries, re-“decide” style. On-going training is doing the work of slowly compressing these judgments that must be remade every time into the weights. Once a certain judgment becomes the model’s instinct, that layer of protocol no longer needs to be transmitted in the next interaction — protocol cost on that dimension truly goes to zero.

So the cleanest diagnostic is this: the true degree of flattening in your AI system is not measured by how many layers of agents you have. It is measured by: “Does something you taught it today need to be retaught tomorrow?” If it must be retaught every time, your system is flat only on the surface. If it doesn’t, you are truly walking toward an army of 300,000.

VI

If you are building an AI system right now, what does all this mean for you? Four questions can serve as a health check.

First: Do your agents communicate via JSON or natural language? If your planner passes instructions to workers as a paragraph of Chinese or English, you are having your wu-leaders issue orders by chat. Replace it with typed tool calls, structured messages, and function schemas — this is the cheapest and most immediately effective improvement of all.

Second: Is your orchestrator overreaching into execution? If your planner agent starts writing code, editing files, or adding database fields itself, your Berthier has mounted a horse and ridden to the front lines. Pull execution fully back into the worker agents; let the planner only do decomposition and merging. This is the “architectural correction” most teams need to make next.

Third: Where is your strongest model? If your flagship model is in scheduling and your small model is in execution, flip it. Mid-tier models are already sufficient for planning; the long string of tool calls, the series of detailed judgments that truly determine your product quality, need the most expensive model in the house to carry them. This advice will raise your bill, but it usually also makes your product’s reliability jump a tier.

Fourth: Are you feeding failure trajectories back as training data? Every wrong diagnosis in production, every diff rejected by a user, every answer graded zero by a grader — is there a pipeline to collect it, grade it, and pour it back into the next version of the model or the next version of the retrieval pool? If this pipeline doesn’t exist, your AI system wakes up every day as the same raw recruit. If it exists, your system grows more like a veteran every day.

With these four questions answered, you can probably guess whether you’re closer to Han Xin or to Xiang Yu.

VII

Return to that conversation between Liu Bang and Han Xin.

Han Xin said he could command an army of any size. Liu Bang laughed and asked him: if you’re so good at commanding troops, how were you still captured by me? Han Xin’s reply — “Your Majesty cannot command soldiers, but excels at commanding generals” — reads today almost like a prophecy about AI. Organizational capability and execution capability are two different kinds of intelligence, and neither can substitute for the other. But one level deeper, both abilities are propped up by the same thing: protocol.

Han Xin’s protocol was gongs, drums, and signal flags. Liu Bang’s protocol was enfeoffing non-imperial kings. Napoleon’s protocol was the corps system. The protocol of today’s best AI teams is typed tool calls plus on-going training.

AI hasn’t flattened organizations. AI is simply the first technology to put a precise price on “protocol cost.” When your protocol cost can be driven near zero, your organization is truly flat along that dimension. When your protocol cost can’t be driven down, you are just like Xiang Yu: in your entire life, you will never command more than one hundred thousand troops.

Which kind you are depends entirely on the shape of the prompt you write today.