An interactive essay by Chris Wang & Claude Code
You already know how to do your work.
You explain it to colleagues every day.
What if explaining it was doing it?
You describe your work in natural language. Not a prompt. Not a structured form. Just a conversation — the way you'd explain it to a colleague over coffee. The system listens.
Your words dissolve into structured intent. Tasks, dependencies, constraints, preferences — all extracted from natural conversation. No forms. No configuration. Just understanding.
Every field in a form is a question the system couldn't answer itself. Every dropdown is a failure of intelligence. When the system truly understands, the interface disappears.
A master intelligence receives your description and begins to decompose. Not just parsing — understanding. It identifies the sub-tasks, the dependencies, the expertise each piece requires.
One large, ambiguous intention shatters into six, eight, twelve specialized tasks. Each with a clear scope. Each assigned to a sub-agent built for exactly that kind of work. Decomposition is the first act of intelligence.
From your casual description, a directed graph emerges. Nodes connected by data flows. Parallel branches where tasks are independent. Sequential chains where one feeds the next. Structure from conversation.
Flocks of starlings. Colonies of ants. Schools of fish. Nature discovered that many simple agents, following local rules, produce emergent global intelligence. No central controller. Just coordination.
A single starling can't navigate a murmuration. But thousands together create breathtaking, adaptive patterns. The intelligence isn't in any individual agent. It's in the swarm.
Sub-agents are the starlings. The queen agent sets the flock direction. Each worker follows local rules — its specialization, its inputs, its constraints. From this, coherent output emerges.
The best interface is no interface.
Just a conversation.
The queen agent holds the full picture. It understands your intent, the constraints, and the shape of the outcome. From this understanding, it spawns specialized workers — each carrying a piece of the whole.
The queen doesn't do the work. It directs the work. Allocating context, assigning specializations, routing information between workers. An orchestrator, not an executor.
Three workers for a simple task. Twelve for a complex one. The swarm scales to the problem — not to some fixed UI constraint. Intelligence on demand, at exactly the right granularity.
One writes. One analyzes data. One structures output. One reviews for consistency. Each sub-agent is specialized — carrying only the context it needs, focused on exactly one dimension of the problem. Division of cognitive labor.
Workers aren't isolated. They stream data to each other. The analyst's output feeds the writer. The structurer shapes the reviewer's input. A living network of intelligence, not a batch process.
Independent branches run simultaneously. The writer doesn't wait for the analyst if they don't need to. Parallelism isn't a feature. It's the natural consequence of graph topology.
At first, the swarm looks chaotic. Agents working in parallel, partial outputs streaming, data flowing in every direction. But look closer. Order is emerging.
Gradually, the chaos resolves. Individual streams coalesce into coherent artifacts. A document. An analysis. A structured dataset. Each one complete, consistent, and interconnected.
This is the magic of swarm intelligence. No single agent produced the final result. It emerged from the coordination of many. The whole is greater than the sum of its parts.
You don't manage the agents. You don't even see them.
You just describe the work.
The user sees a conversation. A simple text input. Maybe a few artifacts appearing as they're completed. That's it. The entire swarm — dozens of agents, complex data flows, parallel execution — is invisible.
Behind that simple interface, a network of intelligence is working. The queen decomposes. Workers specialize. Data flows converge. The sophistication is in the system, not the interface.
The hardest design problem isn't making complex things look complex. It's making complex things feel simple. The swarm's power comes from what it hides, not what it shows.
You adjust one artifact. That correction doesn't stay local — it ripples through the swarm. The queen learns your preference. Future workers inherit the pattern. One correction, systemic improvement.
Session 1: you correct 15 things. Session 10: you correct 5. Session 50: the first generation is already 95% right. The swarm doesn't just execute. It learns.
Each session makes the next one better. Preferences, patterns, corrections — all accumulate across time. This isn't a tool you use. It's an intelligence that grows with you.
A single person describes their work. The swarm produces five artifacts, ten artifacts, twenty — as many as the task demands. The bottleneck is no longer bandwidth. It's imagination.
One conversation spawns a swarm. One swarm produces a constellation of outputs. Each output is specialized, coherent, consistent with the rest. The leverage is not linear. It's exponential.
Work shifts from production to direction. From making to orchestrating. From typing to thinking. Intelligence that scales is intelligence that swarms.
Intelligence that scales
is intelligence that swarms.
You don't need to learn a new tool.
You don't need to write better prompts.
You just need to describe your work.
The swarm handles the rest.
Talk to it. Let it build.