"which model is smarter" holy wars are boring now. everyone runs roughly the same models - the results differ wildly. the real gap is elsewhere: who orchestrates how. i've seen a pile of setups over the past year - they all fold into three levels. let's start simple, so it clicks even if you installed your first agent yesterday, then dive deeper
theory in plain words
a model by itself is text-in-text-out: you ask - it answers. that's it.
an agent is a model put into a loop and given hands: terminal, files, browser. it takes a step - looks at what happened - takes the next one. until the task is done (or the context runs out, more on that below)
orchestration is the answer to one question: who decides what happens next. you? the agent? an agent above other agents? a cron on a schedule? that answer defines the main metric - how much of your time one feature costs
and the through-line for this whole post: the higher the level, the less prompts matter and the more rules do. a prompt lives one session, a rule (an md file, a skill, a repo convention) lives forever. remember this, it comes back below
level 1 - manual
you sit in a chat with an agent, control every step, eyeball every diff. ask - look - fix - next
slow? yes. but honestly this is a mandatory stage, you can't skip it. this is where trust gets calibrated: you learn what the model carries on its own and where it consistently falls over. without that calibration the upper levels turn into either re-checking everything (then why automate at all) or checking nothing (then enjoy the surprises in prod)
manual forever stays the right mode for two things: critical code (auth, money, migrations) and an unfamiliar codebase
level 2 - semi-auto
you're still in the chat, but you're no longer talking to the executor - you're talking to the orchestrator: the agent spawns other agents and routes work between them. you steer one - it steers ten
why bother, plain words: an agent has an attention limit, like you on a friday evening. the context window is the scarcest resource: read twenty files - started forgetting the first ones. subagents solve this with division of labor: each digs its own corner in its own clean context and only brings the distilled summary up. the orchestrator holds the picture, workers hold the details
how it looks in real tools:
- subagents in Claude Code: the main agent hands out subtasks, each subagent gets its own context, they run in parallel
- threads control in Codex: one session forks child threads off itself. the killer detail is fork_context: a fork inherits the parent's whole memory, so the clone doesn't need the project explained again. limits are tuned via agents.max_threads (default 6 parallel) and max_depth (default 1 - so clones don't breed clones forever)
level 3 - auto
here you're not in the chat anymore. three working formats
loops / cron
a job fires every 15 minutes or so, catches a new pull request, reviews it, replies or merges. without you
and here the opening thought returns: the magic is all in the rules. an agent in a loop doesn't reason about "the right way", it reads "how it's done here" - from the repo, from md files, from skills. write the rules once - they run every 15 minutes forever. wildly underrated format, works hard
spec-driven
you hand over a spec, answer the agent's questions and go about your day. in the evening you check what came out
that's the level Droid by Factory AI gives you with its mission control. and the killer feature there is mixing model families in one pipeline:
fresh heat on this topic: GPT-5.6 Sol - OpenAI's new frontier, dropped last week. intelligence on par with Fable 5 by anthropic, but way more token-efficient (Altman claims -54% tokens on agentic coding) and roughly half the cost on real tasks. which makes the pipeline math perfect: Fable 5 thinks and verifies, Sol digs. the smart one plans - the efficient one executes
ultracode
and the simplest entry into full autopilot - the ultracode mode in Claude Code. splits a task into the same stages: orchestration/planning -> workers -> verification. the difference with Droid is philosophical: Droid's stages are nailed down, ultracode's are dynamic - the model itself decides how to assemble the workflow, how many workers, validations and retries it needs. the dashed part of the diagram above - that's it
the subscription lifehack
you don't have to pay for a Droid subscription. grab CLIProxyAPI or VibeProxy - they hook into your existing Codex/Claude account via oauth and expose a local API right on your machine. point the endpoint in config.json - and mission control runs on subscriptions you already have
*VibeProxy - apple silicon only, a menubar app. CLIProxyAPI - cross-platform, go
the takeaway
orchestration level = the price of a feature in your time. manual costs you an evening, semi-auto an hour, auto - five minutes for the spec and the rules
and yes, rules beat prompts. start there
you sleep - agents work)