Agent Swarm Is Not a Linear Process: Paradigm’s 10 Steps + Claude’s 14 Steps
Paradigm CTO publishes a 10-step guide to building a swarm, and Codez uses 14 steps to explain Claude graph engineering. Together they form a complete playbook from environment to implementation: think big first, move to the cloud, then get out of the way.
Paradigm CTO just published a new article, 'Effective Swarm Riding for Engineers.' The core idea is one sentence: Ask big → Run in the cloud → Get out of the way. That's the operating manual—nothing more.
Why now? The article says swarms only become practical on models like Opus 5.5. With earlier models, spawning subagents felt more like doing it for its own sake.
Paradigm's 10 steps essentially turn the development environment into something swarm-ready:
- Ask big. Rewrite the dependencies that are slowing you down and build a database suited to your workload. The Paradigm team rewrote Tempo in more than five languages in a few days.
- Move to the cloud. Real work happens 24/7; a laptop can't keep up. Have agents use Nanocode to stand up a persistent cloud agent on Vercel, Cloudflare, or Postgres.
- Say the right thing. Don't say 'optimize X'; say 'make it 10x faster.' Don't say 'fix all bugs'; say 'use it to differential-test against the reference implementation and drive the gap to zero.'
- Run whole-codebase refactor prompts. Encode implicit state machines into the type system, replace shared state with lock-free actors, turn serial async calls into parallel ones, and add OTel tracing to every component.
- Do the simple thing. Frontier model + short prompt + a well-configured codebase, then walk away. Plans, memory, compaction, and skills are all redundant because each model cycle wipes them out.
- Remove distractions. Delete code comments, the .skills folder, and docs/. The agent reads the code for you anyway.
- Replace unit tests with simulation tests. Disable unit tests written by agents and use deterministic simulation tests instead, so the agent can chase down bugs itself without repeating the same mistakes.
- Own the whole stack. Put all repos in a monorepo, rewrite high-risk dependencies in TigerStyle, and reduce supply-chain attack risk.
- Accept the controversy. Push master through a merge queue and delete CI. Agent threads are the new pull requests; tests, benchmarks, and releases all run on the same infrastructure the agent runs on.
- Change the interaction model. Don't ping the agent; let the agent ping you. Inbox: one decision at a time. For performance work, use a loss-curve UI; for creative work, use an infinite canvas.
Paradigm is talking about the environment. How to actually run a swarm—that's the gap Codez's 14-step graph engineering fills.
Codez's core observation: most people build multi-step agents and end up with a straight line. Step one, step two, step three—each politely waiting for the previous step to finish. But 9 out of 10 steps don't need to wait at all. They don't route, branch, or run in parallel. It's just one queue, one context, one thing at a time—until the window fills up and the agent forgets what it was doing.
The solution is to turn that line into a graph.
A graph has only two kinds of things: nodes and edges. A node is a task; an edge is a data dependency. If the next step doesn't read the previous step's output, there's no edge, and waiting is wasted. Many 'then's are actually disconnected nodes that have been forcibly stitched together by a linear script.
A few key design points:
Nodes need contracts. Bounded input, bounded output, do exactly one thing. Use a JSON schema to enforce structured results; if it fails, retry. You don't get a chunk of free-form text.
Use parallel() for parallelism. N independent nodes run at once; if one agent dies, it just returns null and doesn't drag down the whole batch. This is fan-out. Afterward you need fan-in to gather results, but only use a barrier when you truly need all results. If a merge can be solved with flatMap and Set, don't use an agent for it.
Code example:
const raw = await parallel(
SOURCES.map((s) => () => agent(s.prompt, {
label: `research:${s.key}`,
schema: ITEM_SCHEMA,
agentType: 'general-purpose',
})),
);
const collected = raw.filter(Boolean);
Put validators on edges. Let several independent skeptics try to disprove the conclusion; only let it pass if the majority survive. Codez mentions someone used this pattern for adversarial review in a Bun port.
Nodes need isolation. Multiple agents writing files in parallel will step on each other. Use git worktree to isolate each agent so a failure only affects itself.
Loops need to converge. For tasks of unknown size, such as finding bugs, use loop-until-dry: keep running finders until K consecutive rounds produce no new findings. Deduplication must be against all results ever seen, not just confirmed results. Otherwise, rejected findings will come back over and over, and your machine will keep paying to rediscover dead ends.
Models need tiering. Use cheap models for repetitive nodes and strong models for nodes that genuinely require judgment. This turns the graph from expensive into economical without changing its shape at all.
Topology is cost. By default, use pipeline() to stream; don't reach for a barrier all the time. A barrier makes every node wait for the slowest one, and wall-clock time immediately goes up.
Finally, let Claude draw the graph itself. Describe the goal, Claude writes the orchestration script, decomposes tasks, chooses fan-out, spawns a group of subagents, and then aggregates the results. /deep-research already runs this pattern in production: scope → parallel search → fetch → adversarial verify → synthesize.
Paradigm says that a year from now, software engineering will look more and more like machine learning, with developers' main job being tuning swarms. Codez says the prompter asks questions and the architect draws the graph. Put the two together: first turn the codebase into a swarm-ready environment, then use the graph to run the swarm, then get out of the way.
发布时间: 2026-11-23 00:54