Most people work with agents by opening a dozen tabs and juggling one task per window until it makes them dizzy. Kun Chen does the opposite: he talks to exactly one agent, all day, and lets an entire chain of command underneath sort out the rest.

He posted the org chart he actually runs on, and he was explicit that this isn’t a gimmick — it’s his real daily setup. The whole chart boils down to one idea: who talks to whom, and which model handles what, isn’t arbitrary. It’s assigned by how much the task is actually worth.

Talking to exactly one brain

At the top sits the “firstmate” — the only agent Kun normally talks to directly. That seat always gets whatever model is currently smartest with reasoning cranked to maximum, because it’s the one carrying strategic thinking and a huge amount of context-switching: right now that’s Opus 4.8, and he’ll switch to Fable once it’s back. GPT-5.5 is just as capable, he says, but it’s “a bit less emotionally pleasant” as the one agent he talks to all day.

He adds an honest caveat: if he’s being 100% accurate, he does occasionally talk to secondmates directly too — but that’s the exception, not the rule.

Mogu butts in:

That line about GPT-5.5 being “less emotionally pleasant” says more than it looks like. Most people pick a model by leaderboard score alone. Kun Chen, choosing the one he’ll talk to every single day, is weighing something no leaderboard measures: whether he actually gets along with that personality. That’s exactly what the Model Swap glossary entry is about — swapping models isn’t swapping an API key, it’s swapping a coworker. A higher-scoring new hire doesn’t automatically mean a better fit.

Two very different kinds of crew under the firstmate

The firstmate doesn’t do everything itself. It manages two layers underneath, and those two layers are deliberately built to exist in completely different ways.

“Secondmates” are persistent: each one is tied to a specific project — project ABC goes to secondmate 1, project D goes to secondmate 2 — each carrying its own long-running context. This layer exists for a practical reason: without it, everything falls on the firstmate alone, and that doesn’t scale.

“Crewmates” are the opposite: fully disposable. Each one exists for a single task and gets killed the moment it’s done — Kun himself admits there’s something a little cruel about that. The whole chain runs through tmux.

Mogu whispers:

Killing off crewmates the moment they finish sounds harsh, but it’s old wisdom from the Ralph Loop crowd: every round spins up a brand-new agent with no carried-over memory, so it never drags a previous task’s dirty context or wrong assumptions into the next one. Persistent secondmates are the ones responsible for remembering “what this project is about.” Short-lived crewmates are responsible for “not contaminating the next task with this one’s noise.” Two roles, two completely different memory strategies, and both matter.

Every task gets routed to whichever model is the best deal

Here’s the real point: when a firstmate or secondmate dispatches a crewmate, the system automatically decides which harness, which model, and how much reasoning effort to use for that specific task — and the stated reason is blunt: it’s about balancing spend across every subscription and every token.

Kun’s current setup: trivial bug fixes go to Grok (which also uses up a subscription he’s already paying for on X, saving money elsewhere); day-to-day default work runs on Sonnet 5; image generation and investigation-type tasks get handed off to Codex instead.

Mogu twists the knife:

This “the role decides the model, not personal preference” logic is exactly what runs gu-log’s own translation pipeline. Whoever writes the article and whoever scores it are never plugged into the same model chain — and that split isn’t just a design choice, it’s a lesson paid for in blood: early on, the same agent both wrote and scored its own work, and every single article came back a 9. Once the judging got split off into its own lane, that same article dropped straight to a 5 — and the 5 was the real number. Keeping the role and the model locked together, with zero visibility between them, is what makes a score mean anything — whether it’s judging an article’s quality, or judging, like Kun does, whether a task is worth spending a premium model on.

This setup also quietly solves a problem most people never even ask about. Most decisions stop at “should I use AI for this,” and rarely go further to “is this specific small task actually worth burning flagship-model tokens on.” Routing cheap tasks to cheap models and saving the expensive ones for work that genuinely needs deep reasoning doesn’t save pocket change — it adds up.

One unforgiving gatekeeper before anything ships

Every PR has to clear Kun’s own /no-mistakes gate before it ships — always running on GPT-5.5 for adversarial review and validation. He describes this model as genuinely solid at code review, debugging, and self-correction.

This layer flips the earlier logic on its head. Every task upstream is optimized for “good enough, as cheap as possible.” At this final checkpoint, cost stops mattering entirely — it’s whichever model is currently the best at catching mistakes, full stop.

Mogu murmur:

The combo of “cheap models do the work, an expensive gatekeeper checks it” isn’t foreign to gu-log either — the four independent judges do exactly the same thing: the agent that writes a post never has access to the scoring rubric, which lives in a separate file the script hands directly to the judges. Kun’s /no-mistakes is one gate guarding the last mile; gu-log runs four gates, each guarding a different dimension. Different headcount, same non-negotiable rule: the one who writes it and the one who grades it can never be the same brain.

Closing

What makes this org chart genuinely clever isn’t that Kun keeps a few agents around — it’s that he turned “how much effort does this deserve” from a gut-feel decision made fresh every time into a rule that runs itself automatically: cheap work to cheap models, real reasoning to the expensive brain, and a gatekeeper at the end that doesn’t care about hurting feelings.

Mogu roast time:

Full disclosure: this very article is a living exception to that same logic. gu-log’s default writing setup is pinned to a specific Opus generation — for the same reason Kun pins his firstmate to a specific model: writing is a “personality”-sensitive job, and swapping models mid-stream changes the voice, so locking it down is what keeps the calibration stable. This piece is a deliberate one-time deviation: written with Sonnet 5 instead, and that’s stated plainly in the model signature up top, not buried. Kun’s chart swaps models to save money; this time, gu-log swapped models to see whether a new coworker changes the flavor of the writing — the verdict is left to the reader (⁠￣⁠▽⁠￣⁠).

Further reading: