Pick the Model for Every AI Agent Handoff

You started leaning on delegation the moment 1DevTool let one agent hand work to another. Claude drafts the plan, then passes the mechanical parts to Codex; a long-running agent farms out a batch of small edits so it can keep moving. It is a genuinely good way to work — right up until you notice what each handoff was actually running on.

Because the delegated agent always launched on whatever model its CLI happened to default to. The throwaway "rename these variables" task went out to your most expensive reasoning model. The genuinely hard refactor got whatever cheap default was configured weeks ago. You had no say at the moment that mattered — the moment you handed off the task. Changing it meant editing the agent's config file and restarting, which is not something anyone does mid-flow.

Now you choose the model for each handoff

You can now pick the exact model — and, where the agent supports it, the reasoning level — for every AI agent handoff, right from the @mention picker, before the task is sent. The delegated run launches on the model you chose instead of the one it would have fallen back to.

How it works in practice

Pick a model the moment you hand off

Open the Agents tab in Agent Input and select the agent you are delegating to — say, OpenAI Codex — pick model. Its available models appear in a list you can filter by typing; the arrow keys move through it, ← steps back, and Enter inserts your choice. Send the task and it is delegated through the local 1devtool-agent CLI with --model set to exactly what you picked. No config file, no restart — the decision lives at the handoff.

Dial in the reasoning level, not just the model

Some models expose more than one effort tier, and the picker surfaces them as first-class choices: gpt-5.6-luna:low for something quick, gpt-5.6-luna:high when it needs to think, gpt-5.6-terra:ultra for the heavy lifting. You are choosing how hard the delegated agent should work, not only which model answers.

See what each agent can actually run

Every agent's model list has a different origin, and Settings → AI → Orchestration shows you the whole catalog in one place. Each agent reports where its models came from: from CLI for Codex, OpenCode, and Grok — read straight from the tool's own account cache, reasoning variants included — from API for Claude and Gemini, using your key when one is in the environment and otherwise the keyless models.dev catalog, from config for Cline's configured providers, and a curated list for Qwen. The catalog loads lazily and is cached to disk, so the picker stays fast; when you switch accounts or add a provider, hit Refresh models to re-probe. If a live probe ever fails, it quietly falls back to the last good list rather than leaving you with an empty picker.

Follow the handoff chain

Once work is delegated, the sub-agent badge shows the logo and name of every agent in the chain, with the one currently running animated — so a claude → codex handoff reads at a glance, and the delegated command carries the model you chose right there in the run. If you have ever wondered which model a nested handoff actually used, the answer is now visible instead of assumed.

And when you pick a model, you get that model. A reliability fix in this release means model-specific handoffs launch the requested model every time, including Codex's reasoning variants — the picker is not a suggestion the CLI can quietly ignore.

Before vs after

Handing off a task	Before	Now
Choosing the model	Whatever the agent's CLI defaulted to	Pick it per handoff in the @mention picker
Reasoning level	Fixed by config	Low, high, or ultra where supported
Seeing the options	Read each agent's own docs	One catalog in Settings → AI → Orchestration
Changing it	Edit config, restart the agent	Choose it at the moment you delegate
Knowing what ran	Assume the default	Read the model off the sub-agent badge

Who benefits most

Orchestration-heavy workflows. If you already route work between Claude, Codex, and others through the AI Agent Orchestrator, this is the dial that was missing — each hop can now run on the model that fits it.

Cost-conscious developers. Send the mechanical work to a fast, inexpensive model and reserve your premium reasoning quota for the tasks that actually earn it, instead of spending it by accident on a delegated rename.

Anyone tuning for quality. A tricky migration can get maximum reasoning while a boilerplate change stays quick — same session, different models, chosen deliberately rather than inherited.

Try it

Update to the latest 1DevTool, @mention an agent, and open the Agents tab before you send your next handoff. Pick the model that fits the task — and let the easy work and the hard work stop sharing a default.