If you only take one idea from this notebook, take this: the frontier coding agents have converged on raw capability but diverged on temperament. They fail differently, wait differently, and cost differently. Running several isn't indecision — it's how you get the best of each, plus a second opinion for free. Here's how the bench is laid out, with the actual patterns I use.
§1The lineup
Claude
the daily driver · AnthropicThe lead. Claude Code runs in the terminal and does the bulk of the work: multi-file refactors, audits, research writing, incident forensics, and anything where judgement-per-token matters more than raw speed. It's the one I trust with the risky, irreversible changes, because it reasons about blast radius and asks before doing something it can't undo.
▸ Best at: judgement, long-horizon multi-step work, "think before you touch it."
Codex
the executor · OpenAIFast, literal, tireless on well-specified mechanical work. When the decision is already made — apply this change across these files, wire up this endpoint, grind through this refactor — Codex just executes. It has a "fast" profile for throughput over deliberation, and I keep a second config that points it at a local model for offline or private runs.
▸ Best at: specified execution, throughput, "I've decided — just do it."
Droid
the operator · FactoryFactory's agent leans operational: it holds background processes, scheduled runs, its own skills and specs, and an MCP tool layer. I reach for Droid when the work is less "write this code" and more "run this thing, on a schedule, with these tools wired in." The most infrastructure-shaped of the four.
▸ Best at: background/scheduled tasks, tool-heavy operational workflows, standing automations.
Cursor
the editor · AnysphereCursor is hands-on-keyboard editing — the IDE for when I want to see the code and steer inline, plus a CLI agent for quick one-shots. It shines on tight, interactive loops: read a file, change a function, watch the diff, iterate. Project rules live in-repo so every session starts already knowing the house style.
▸ Best at: interactive editing, tight human-in-the-loop iteration, "let me watch it happen."
§2Which one gets the job
The routing isn't rigid, but the instincts are consistent. Route by consequence and temperament, not by task type:
| When the work is… | Reach for | Because |
|---|---|---|
| Ambiguous / high-stakes | Claude | weighs blast radius, asks before irreversible moves |
| Decided / mechanical | Codex | fast, literal execution without re-litigating |
| Scheduled / tool-heavy | Droid | built for background runs and standing automations |
| Interactive / visual | Cursor | see-the-diff, steer-inline editing loop |
| Private / offline | Codex + local model | no data leaves the machine, zero marginal cost |
| A second opinion | a different one | agents fail differently — divergence catches mistakes |
§3The real trick: one brain, four bodies
Four agents that each learn your project separately is four times the onboarding and four subtly different versions of the truth. The highest-leverage thing in my whole setup is fixing that: one canonical context file, mirrored into the format each agent reads at startup.
Each agent looks for its own house-rules file. Claude reads CLAUDE.md; Cursor and Codex read AGENTS.md; Droid reads its own AGENTS.md. So I keep one source of truth and mirror it into each name:
the canonical rules file, written once
# context.md — house rules every agent shares
- Stack: static HTML/CSS/JS, no build step. Deploy = CDN push.
- Never touch production without an explicit go-ahead.
- Bump the ?v= on any changed asset; verify one version site-wide.
- One fact, one owner. Don't restate a value in two files.
- After a task: capture anything durable and non-obvious.mirror it into every agent's native filename
# from the repo root — one source, four readers
cp context.md CLAUDE.md # Claude Code
cp context.md AGENTS.md # Cursor + Codex both read this
cp context.md ~/.factory/AGENTS.md # Droid, loaded in every dir
# put a global copy where each agent looks outside the repo, too
cp context.md ~/.claude/CLAUDE.md
cp context.md ~/AGENTS.mdUpdate the source, re-run the mirror, and all four agents are current at once. Every one of them, in any directory, boots with the same rules.
Don't teach four agents four times. Keep one canonical rules file and mirror it into each agent's config format. The dedupe rule is absolute: one fact, one owner. A value that lives in four prompts is a value that's wrong in at least one — and you won't know which.
§4Driving them: the shapes I actually use
All four take a one-shot prompt on the command line or an interactive session. The muscle memory:
one-shot, when the task is fully specified
# hand a decided task straight to the executor
codex "apply the rename from foo() to renderFoo() across src/, keep tests green"
# hand an ambiguous, high-stakes task to the one that pauses to think
claude "the deploy is serving a stale asset to some users — find why, propose a fix, don't ship yet"a good first prompt for a fresh session on an unfamiliar repo
Read the house-rules file and the project README, then summarise the
current state and the risky areas BEFORE changing any files.The second one matters more than it looks: a fresh agent that orients before acting makes far fewer of the confident-but-wrong moves that make people distrust AI in the first place.
§5What running four teaches you
- Capability converges; behaviour doesn't. They're all strong now. You choose between them on how they act — do they pause on ambiguity, run in the background, let you watch — not on a benchmark.
- Divergence is a feature. When two agents disagree about an approach, that disagreement is a free code review. Bugs that survive one often don't survive a second with different instincts.
- Match the agent to the risk, not the task size. A one-line change to a checkout path is "high-stakes," not "small." Route by consequences.
- Shared context beats a smarter model. A slightly weaker agent that knows your rules cold beats a stronger one improvising blind. Invest in the context file before you argue about which model is smartest.
- Voice makes multiplicity cheap. Driving four agents by keyboard would be exhausting; dictating to them is what makes the fleet practical.
Steal this
- Run more than one frontier agent. They fail differently, and divergence is free review.
- Route by consequence and temperament: judgement→Claude, execution→Codex, ops→Droid, interactive→Cursor.
- Keep one canonical context file; mirror it into every agent's filename. One fact, one owner.
- Keep a local-model config for private/offline runs.
- Open a fresh session with "orient before you touch anything."