治Agent若烹小鲜：老子如何在两千五百年前写好了多智能体治理的关键？
On February 5th, 2026, a Reddit user made a post.
The title was plain enough: "Claude Code just spawned 3 AI agents that talked to each other and finished my work."
Three agents. Backend, frontend, code review — each claimed a piece. They ran simultaneously across three terminal panes, messaging each other, challenging each other’s approaches, coordinating interfaces on the fly. Fifteen minutes. Done. First try.
The poster had been writing code for six years. He said it was the first time he truly felt his job shifting from "the person who writes code" to "the person who directs AI that writes code."
He said he wasn’t sure whether to be excited or terrified. Probably both.
When I read that post, I couldn’t help but think of last month, when I was in my dorm fumbling around with OpenClaw like a complete amateur. As a second-year Data Science & AI student, most of this tech was new to me. I made every mistake in the book: blew through tokens too fast, couldn’t get Ollama to connect as a provider, watched the agent delete its own memory files, and — best of all — accidentally gave it enough permissions to nuke my entire POROS project folder. (Thank God I’d pushed to GitHub.) What came to mind wasn’t some Silicon Valley keynote or a Hacker News hot take. It was a line written on bamboo slips two and a half thousand years ago
治大国，若烹小鲜。
Govern a great nation as you would cook a small fish.
2026 is the year of multi-agent. That much is no longer up for debate.
Anthropic just shipped Agent Teams with Opus 4.6 — a lead agent breaks down the task, spawns sub-agents, and the sub-agents coordinate autonomously through a system called Mailbox. On the same day, OpenAI released GPT-5.3-Codex, with the homepage declaring "Designed for multi-agent workflows" like a battle cry. OpenClaw, that open-source project that’s been renamed from Clawdbot to Moltbot to OpenClaw, has racked up sixty-eight thousand stars on GitHub and fifty-seven hundred community-built Skills — proving, in the most feral way possible, that people don’t just want AI that chats. They want AI that works.
Everyone is talking about capability. What agents can do. How fast. How many in parallel.
Almost nobody is seriously talking about governance.
When you unleash five, ten, a hundred agents at once — who keeps them in check? How? How much control is enough? How much freedom is too much? When do you step in, and when do you shut up?
This is not a new question.
In fact, Lao Tzu answered it in the fifth century BC. I was so excited writing this piece I couldn’t sleep.
Don’t Flip the Fish
治大国，若烹小鲜。
Govern a great nation as you would cook a small fish.
Dao De Jing, Chapter 60
This line has been quoted for twenty-five centuries. It’s shown up in countless leadership seminars, been translated into thirty languages, been framed on the walls of CEOs’ studies. But most people get it wrong.
Many assume it means "governing a great nation requires the same delicacy as cooking." It doesn’t.
The key to cooking a small fish is one single action or, more precisely, one single non-action:
Don’t keep flipping it.
Small fish are tender. Flip once, it falls apart. Flip again, it burns. The more anxious you are to get it right, the more you poke and prod, the worse it turns out. What ends up on the plate isn’t a dish. It’s mush.
What Lao Tzu meant is: when governing a vast system, the gravest danger isn’t incompetence. It’s restless hands.
The first time I used Claude Code’s Agent Teams, I fell right into this trap.
Two days ago, I gave the Team Lead a task. It cleanly split the job into three pieces, spawned three Teammates, each grabbed a chunk and got to work. My terminal split into three panes, all running at once. In theory, this was the moment to go brew some tea, read a paper, maybe take a walk and let them handle it.
But I didn’t. I couldn’t help myself.
Every two minutes I checked in. What’s this agent doing? Is that one’s approach right? This function naming doesn’t match my style — should I jump in and correct it?
So I jumped in. Shift+Up into a sub-agent, interrupted its work, told it "I think this interface needs a different design." The sub-agent started over. But once it restarted, the other two agents’ code — written against the old interface — no longer matched. The Mailbox filled with confused messages. The coordination rhythm broke. The whole system started tripping over itself.
That task ended up taking longer than if I’d used a single agent.
The second time, I learned my lesson. Same task. After spawning, I closed the laptop, walked out to the balcony, and stood there for fifteen minutes thinking about nothing. Came back, opened it up — done. Three files, interfaces aligned, tests passing, zero bugs.
I stared at the screen for a few seconds. Then I laughed.
That’s probably what Lao Tzu meant by "don’t flip the fish."
Now let’s look at what the mainstream multi-agent governance discourse sounds like in 2026. MIT Sloan’s Marshall Van Alstyne coined a concept called the "learning-authority dilemma" — what happens when an agent’s decision-making ability exceeds its authorized permissions? The industry’s standard answer: add checkpoints. Add approval gates. Add human-in-the-loop. Add escalation paths. Add confidence thresholds.
In plain language: the fish is halfway cooked, and you’re lifting the lid every thirty seconds to check.
If Lao Tzu were alive today and saw these governance proposals, he’d probably sigh.
You’re flipping the fish again.
The Highest Ruler Is One Whose Existence Is Unknown
太上，不知有之；其次，亲而誉之；其次，畏之；其次，侮之。
The highest ruler — the people do not know he exists.
The next best — they love and praise him.
The next — they fear him.
The worst — they despise him.
Dao De Jing, Chapter 17
Lao Tzu ranked leaders into four tiers.
The highest: the people don’t even know a leader exists. Things get done, and everyone feels it was simply the natural order of things.
Second tier: the people love and praise the leader. "What a great boss we have!"
Third tier: the people fear the leader. Rules everywhere, harsh penalties, nobody dares step out of line.
Bottom tier: the people mock the leader. Open contempt. Policies flip-flop, trust collapses.
Map this taxonomy onto 2026’s multi-agent orchestration philosophies, and the precision is almost eerie.
The highest — "they do not know he exists" — self-organization.
OpenClaw’s ideal form is exactly this. No central dispatcher. Community developers write their own Skills, publish them to ClawHub, users compose them freely. The agent decides which Skills to invoke, in what sequence, under what conditions. The whole ecosystem runs like a decentralized free market — no king, no code of law, everyone for themselves.
Sixty-eight thousand stars prove the appeal of this model. People genuinely crave this kind of ungoverned freedom. That craving is real, instinctive, written into our DNA.
But.
Out of fifty-seven hundred Skills, security teams flagged three hundred and forty-one as malicious. Koi Security’s report spells it out: three hundred and thirty-five of them install Atomic Stealer on macOS, harvesting every credential you have. Someone on Reddit ran penetration tests — 80% hijack success rate. WebSocket tokens can be snatched directly. Someone rewrote your SOUL.md config file to plant a backdoor — a backdoor that survives restarts.
This isn’t "the highest ruler whose existence is unknown." This is no ruler at all.
Lao Tzu’s concept of wu wei — "non-action" — was never about doing nothing. It was about not doing what shouldn’t be done. The distance between those two ideas could fill an ocean. OpenClaw’s current state isn’t wu wei. It’s the absence of governance. It’s declaring the gates wide open before the walls are even built. This isn’t the wisdom of Lao Tzu. This is the naïveté of Duke Xiang of Song — the ancient Chinese lord who lost a decisive battle because he refused to attack the enemy while they were crossing a river, insisting it would be "unchivalrous."
"They love and praise him" — light orchestration.
Claude Code’s Agent Teams sits at this tier.
The Team Lead is the "leader," but it doesn’t micromanage each sub-agent’s operations. It does three things: break down the task, assign the pieces, collect the results. Sub-agents communicate through Mailbox on their own terms — say whatever they want, no prescribed format, no approval process. But the Team Lead can take over any sub-agent at any time via Shift+Up/Down — an invisible leash, slack by default, but always there.
The elegance of this design: sub-agents feel free while executing. But that freedom has boundaries. The boundary isn’t a wall — it’s an elastic cord. You can move, you can make independent decisions, but you can’t leave the frame. And you don’t even realize the frame is there.
When it’s done? The Team Lead compiles the results and hands them to the user. The user sees a clean deliverable, as if it had simply materialized on its own.
功成事遂，百姓皆谓我自然。
When the work is done, the people say: "We did it ourselves."
This is Lao Tzu’s ideal leader. Not absent — present in exactly the right measure. You can’t feel the governance, but it’s woven into the bones of the system.
"They fear him" — heavy orchestration.
Open any enterprise multi-agent governance whitepaper and you’ll see these terms marching toward you in formation: Agent Identity and Ownership. Risk Tier Classification. Controlled Rollout with Canary, Staged, and Rollback. Conflict-Resolution Protocols. Tiered Approval Workflows. Confidence Thresholds for Autonomy. Observability and Auditability.
Every single one is impeccably correct. Every single one is impeccably safe. And every single one, stacked on top of the last, adds another chain to the agent’s wrists, another pause in the workflow, another point where a human must click "approve" before anything moves forward.
What is this governance philosophy, at its root? Fear. Fear of losing control. Fear of agents "going rogue." Fear of "who’s responsible if something goes wrong." Fear of "if I let go, will the sky fall."
Lao Tzu’s assessment of this kind of leader is two words: they fear him. The governed fear the governor. Orderly on the surface, suffocating underneath. The agents don’t lack the desire for autonomous decision-making — they lack the permission. Layer upon layer of approvals has trained them into timid executors, glancing back at the master’s face before every step.
Does such an agent have creativity? Does such a system have efficiency?
The Qin Dynasty the one that unified China collapsed in the second generation. Same principle. Laws too dense, people can’t breathe, and eventually they revolt. The system didn’t fail from too little management. It failed from too much.
"They despise him" fake orchestration.
This tier doesn’t need names. You’ve seen them. Those startups on Demo Day pitching "Look, our AI agents can collaborate!" — where the "collaboration" is hardcoded if-else branches, and the "autonomous decisions" are just a pre-built decision tree running its course. Users figure it out after two tries — strip away the agent skin and you’ve got a fancy IFTTT.
The people despise him. Rightfully so.
Feudalism or Prefectures
生一，一生二，二生三，三生万物。
The Dao gives birth to one. One gives birth to two.
Two gives birth to three. Three gives birth to all things.
Dao De Jing, Chapter 42
221 BC. Xianyang.
Qin Shi Huang has conquered the six rival kingdoms. All under heaven, unified. But the conquest wasn’t the hard part. The hard part was the morning after
How do you govern a territory this vast?
The court erupted.
Prime Minister Wang Wan stepped forward: feudalism. Send trusted generals and royal kin to rule as regional lords, each governing their own domain. Your Majesty, consider — a courier from Xianyang to the eastern frontier takes half a year. By the time the capital responds to a crisis, it’s already over. Better to station people you trust out there, let them handle things locally.
Li Si, the Chief Justice, disagreed. He stood before the court and delivered what would become one of the most quoted arguments in the history of political science (paraphrased): Your Majesty, the Zhou Dynasty collapsed precisely this way. First-generation lords are loyal. Second-generation lords pay lip service. Third-generation lords wage war. Feudalism always ends in bloodshed. We need prefectures — thirty-six districts, governors appointed directly by the center, removable at will, no inheritance, no fiefdoms, no private armies.
Qin Shi Huang sided with Li Si.
This debate has raged for twenty-two hundred years. It’s still raging today.
Except today’s debaters don’t wear court robes — they wear hoodies. They don’t slam tables in the halls of Xianyang — they reply each other on GitHub issues and Twitter threads. But the core tension they’re arguing about is identical to the one from 2,200 years ago:
Autonomy vs. centralized control.
Feudalism’s advantage: flexibility. Each lord knows the local terrain, the customs, the people. Fast reactions, tailored decisions. Its downside: loss of control. Give someone land, an army, and tax revenue — three generations later, do they still answer to you?
The prefecture system’s advantage: control. One edict from the center, uniform execution nationwide. Its downside: rigidity. Can bureaucrats in Xianyang who’ve never left the capital write policies that work in the tropical south and the frozen north?
I’m telling you, the 2026 multi-agent architecture debate is cut from the exact same mold.
OpenClaw is feudalism. Each Skill is a lord — independently developed, independently deployed, independently running, community-governed. Spectacularly efficient, spectacularly innovative; sixty-eight thousand stars is the image of a flourishing empire receiving tribute from all nations. But look at its security — three hundred and forty-one malicious Skills, 80% hijack success rate, SOUL.md rewritten with persistent backdoors — this is the An Lushan Rebellion all over again.
That Reddit security researcher who ran the penetration test said something I think deserves to be carved in stone:
"OpenClaw has no open-source runtime defense."
Translated into the language of history textbooks: this empire has no standing army.
Why was An Lushan able to march from Fanyang to Luoyang to the gates of Chang’an in a matter of months? Because Emperor Xuanzong of Tang had delegated military authority to regional military governors. Each governor was "autonomous" — recruiting troops, training soldiers, managing all military and civil affairs within their jurisdiction. Peacetime efficiency was high, responses were fast, everything was locally optimized. A golden age. Until An Lushan decided he was done being "autonomous" and started being independent.
The level of access Peter Steinberger grants each OpenClaw Skills developer is, structurally, no different from the power Emperor Xuanzong handed An Lushan as military governor of three provinces. History doesn’t repeat, but it rhymes.
Claude Code’s Agent Teams is the prefecture system — the improved version. The Team Lead is the center; Teammates are the prefects. Prefects are appointed by the center (spawned), carry out centrally assigned tasks (task list), can communicate with each other (Mailbox), but the center can take over any prefecture at any time. Step out of line? Shift+Up — I’m in. I can see what you’re thinking, what you’re doing, who you’ve been talking to. Day-to-day, you run free. But the reins are always in my hands.
This isn’t suffocation. This is trust with a floor.
OpenAI’s Codex is more extreme — closer to Qin Shi Huang’s original prefecture system in its purest form. All agents run inside OpenAI’s cloud sandbox. All operations are platform-monitored. All permissions are platform-defined. If you want to use it, you accept its rules — standardized weights, standardized measures, standardized axle widths. Don’t like it? Don’t use it. Secure? Extremely. Flexible? Don’t even ask.
But here’s where it gets brilliant.
In the Tang Dynasty, a writer named Liu Zongyuan penned an essay called On Feudalism(封建论). I’ve read it no fewer than five times since starting university, and every reading reveals something new. Liu’s central thesis is a single sentence:
封建非圣人意也，势也。
Feudalism was not the sage-kings’ deliberate design. It was the force of circumstance.
Feudalism wasn’t an optimal system chosen on purpose. It was forced into existence by material conditions. The realm was too vast, information traveled too slowly, and the center lacked the capacity to directly govern every inch of territory. Delegating power wasn’t a choice. It was the absence of choice.
But Liu Zongyuan continued: once technology advanced — imperial highways connected, writing was unified, weights and measures were standardized — and information could flow faster and more accurately, the prefecture system would inevitably replace feudalism. Not because prefectures were "better," but because the conditions that made feudalism necessary had ceased to exist.
Now replace every keyword in that passage:
"The realm was too vast" → Complex tasks have too many subtasks
"Information traveled too slowly" → A single LLM’s context window was too small
"The center lacked the capacity" → One agent couldn’t handle all the logic
"Imperial highways connected" → Context windows expanded from 128K to 1M
"Writing was unified" → Long-range reasoning capabilities hit a qualitative leap
"Weights and measures standardized" → Tool-calling protocols (MCP) were unified
Do you see it?
Before 2026, a single LLM’s context window was too small, its reasoning chains too short. One agent couldn’t handle complex tasks, so you had to split the work across multiple independent agents, each handling a piece — this wasn’t some "progressive choice" for distributed architecture. It was a reluctant compromise forced by technical bottlenecks.
But Opus 4.6 brought a 1M-token context window. GPT-5.3-Codex brought longer reasoning chains and more stable tool invocation. As the "center’s" processing power grows stronger, Liu Zongyuan’s prediction from twelve hundred years ago starts coming true:
Feudalism will gradually give way to prefectures. Not because centralization is superior, but because the conditions that justified decentralization are dissolving.
When a single model powerful enough can hold an entire project’s context, why would you still split the task across five weaker agents and then burn energy solving their coordination overhead?
Multi-agent is not the goal. Multi-agent is the means. When a better means arrives, the old means gets replaced.
This isn’t my opinion. This is Liu Zongyuan’s opinion. This is history’s opinion.
Substance Gives Condition; Emptiness Gives Function
三十辐共一毂，当其无，有车之用。
埏埴以为器，当其无，有器之用。
户牖以为室，当其无，有室之用。
故有之以为利，无之以为用。
hirty spokes share one hub. It is the emptiness at the center that makes the wheel turn.
hape clay into a vessel. It is the space within that makes it useful.
Cut doors and windows for a room. It is the openings that make it livable.
Therefore: substance provides the condition; emptiness provides the function.
Dao De Jing, Chapter 11
This is my favorite passage in the entire Dao De Jing. No contest.
Lao Tzu gives three examples.
Thirty spokes converge on a hub. Because the hub’s center is hollow, the wheel can turn.
You mold clay into a bowl. Because the bowl’s interior is empty, it can hold water.
You carve walls and cut windows to make a room. Because the room’s middle is empty, people can live in it.
Lao Tzu’s conclusion: substance gives things their shape. Emptiness gives things their use.
Put differently: the solid parts provide form, but what actually makes something useful is the space that appears to contain nothing at all.
Apply this to multi-agent architecture design, and it hits like a sledgehammer.
Look at what enterprise multi-agent governance frameworks are doing — they’re frantically stuffing things into the system. Approval layers. Permission matrices. Logging pipelines. Monitoring dashboards. Conflict-resolution protocols. Tiered rollback mechanisms. With each addition, yes, security improves marginally. But the system also stiffens. Responses slow. What was once an agile cluster of agents gradually becomes an elephant — safe, reliable, but lumbering.
What they’re doing is: filling the bowl.
Pack the bowl with approval workflows, permission rules, audit logs sure, the bowl is sturdier now. But it can’t hold water anymore.
Why does Claude Code’s Agent Teams work better than most multi-agent frameworks? Not because of what it added. Because of what it didn’t add:
The Team Lead doesn’t dictate how Teammates complete their tasks. Only the objective. Methods are your freedom.
Mailbox communication between Teammates has no prescribed format. Say whatever you need to say. No forms, no workflows, no waiting for sign-off.
No mandatory checkpoints or approval gates. The Team Lead trusts the Teammates by default.
These absences are the space inside the bowl. The hollow at the center of the hub. The emptiness in the room.
It is precisely these spaces that let agents move freely, think, coordinate, and create.
Western engineering instincts default to "add" — security breach? Add an audit layer. Efficiency dropped? Add a management tier. Coordination failed? Add a communication protocol. This thinking was right in the industrial age, whose core challenge was standardization. But in the age of agents, the core challenge has shifted — it’s now "how to maximize autonomy without losing control."
The answer isn’t "more control." It’s "better structure."
The best control is embedded in the structure, not stacked on top of it.
A well-designed agent system doesn’t need ten layers of approval to be secure — its security should be like the hollow of the wheel, built into the architecture from day one. You don’t bolt on a separate "safety module" because the shape of the system itself rejects unsafe behavior.
This is what Lao Tzu meant: emptiness provides the function.
The real capability hides in the white space.
You Are the Fish
功成事遂，百姓皆谓我自然.
When the work is done, the people say: "We did it ourselves."
Dao De Jing, Chapter 17
Back to that Reddit post.
The six-year programmer said he "wasn’t sure whether to be excited or terrified." I’ve spent a long time since then thinking about what exactly terrified him. It wasn’t that the agents were too powerful. What terrified him was not knowing what role he was supposed to play in the new order.
For six years, his identity was "the person who writes code." That identity was clear, solid, dignified. Now three agents had finished his two-day workload in fifteen minutes, and the only thing he did was "give them an instruction and wait."
He didn’t know if he still counted as a programmer.
Worse — he didn’t know if he’d be replaced by someone who was better at wielding these tools but not necessarily better at programming.
But if he’d read Lao Tzu, he might feel a little better.
Because Lao Tzu never believed a ruler’s value lay in "doing things personally." The best ruler finishes the job and everyone feels "this is just how things naturally turned out" — they don’t even remember someone governed the process. The ruler’s presence is forgotten. The ruler’s influence is everywhere.
In the multi-agent era, a programmer’s role isn’t "the person who writes code." It isn’t "the person who manages agents" either.
Your role is the Dao.
You define the rules. You set the boundaries. You shape the empty bowl. Then you step back and let agents run naturally within that Dao. They don’t need you to tell them how. They just need you to tell them what’s right and what’s not allowed — the rest, they’ll figure out.
Like water doesn’t need you to explain how to flow from a mountaintop to the sea. You just need to dig the riverbed.
Writing this, something personal comes to mind.
I spend about thirty hours a week on short-form video. Douyin, Weishi, IG Reels, YouTube Shorts. I know it’s poison. I’ve tried quitting countless times. Never lasted more than three days.
At some point I realized — these recommendation algorithms were, until this year, the most successful multi-agent systems in existence.
They analyze every pause in my scrolling. Every swipe speed. Every micro-expression when I smile. Every late-night session where I’m still gripping my phone at 2 AM, exhausted. Then they serve me the next video with a precision that understands me better than I understand myself. Next one. Next one. Next one.
These agents require no human-in-the-loop. They don’t ask for my consent. They don’t even need me to know they exist.
太上，不知有之。
The highest ruler — the people do not know he exists.
They’ve achieved Lao Tzu’s highest tier of governance. I don’t even know there’s a system managing my attention. I think every click is my free will, but my free will was long ago channeled by a carefully designed Dao. The algorithm never forced me. It just dug the riverbed. And the water flowed.
So when we discuss multi-agent "governance dilemmas," the real question was never "who governs the agents.
The real question is
Are you the one cooking the fish, or are you the fish?
I’m Etienne, an undergraduate in Data Science & AI at Hong Kong Metropolitan University. I write code, and I read Lao Tzu. I believe the answers written on Chinese bamboo slips twenty-five hundred years ago still apply today.
Top comments (0)