Give each routine step the right model

One routine, three steps, three different models — a heavyweight for the thinking, a cheap-and-fast one for the grunt work. You pay premium prices only where they actually buy you something.

What you'll build — A multi-step custom routine where each step runs on a model suited to its work: a strong model for difficult reasoning and a lighter model for simple synthesis. Claude or Codex selects valid aliases from the account inventory and validates the result through the Agents MCP.
Who it's for — Anyone running a routine often enough that per-step model choice moves the bill — and anyone who wants a stronger model on the one step that keeps getting it wrong.
Time & plan — About 15 minutes. Any plan with an agents budget. Nothing to connect — this is about the routine itself. Each step bills on whatever model it runs on.

Connect Claude or Codex first

Open an Agent's Tasks tab, choose Connect Claude or Codex, and follow Build routines with Claude or Codex if the Agents MCP is not connected yet.

The idea in one table

By default every step runs on its agent's usual model — you never have to think about it. Pinning a model is an override you reach for deliberately:

Step does…	Reach for…	Why
Hard reasoning, research, judgment	A strong tool-capable model from inventory	Worth the cost where quality compounds
Bulk drafting, reformatting, summarizing	A lighter tool-capable model from inventory	Fast and cheap; the heavy model is overkill here
Everything in between	Leave it unpinned	The agent's default is already tuned

A pinned model must be able to use tools

Routine steps call tools — search, browsing, your connected data. So the model you pin must be tool-capable. General-purpose models are all fine; models aimed only at reading images or churning bulk text are rejected on Save, with the valid names listed. (Name a model by its catalog alias — claude-sonnet, gpt-5, gemini-flash — not a marketing name.)

Steps

1. Ask Claude or Codex to inspect models and Agents

text

Build a three-step topic-research routine. Use a strong model for the difficult
research step, the home Agent's default for competitor analysis, and the
cheapest appropriate tool-capable model for the final five-bullet summary.

Inspect my current Agent and model inventory. Explain the expected quality/cost
tradeoff, use only aliases returned for this account, validate the complete
routine, and show me canonical YAML before saving. Ask separately before a
billed tool-free preview. Do not schedule it.

The coding agent calls get_account_authoring_inventory rather than guessing model names. If it changes an existing routine, it first reads that routine and preserves the fields you want to keep.

2. Review the routine with per-step models

The result has this shape. The aliases below are illustrative; Claude or Codex must replace them with available, tool-capable aliases returned by your inventory and accepted by validate_routine:

yaml

name: topic-deep-dive
display_name: Topic deep-dive
description: Research a topic deeply, scan competitors, then write a tight summary.
archetype: personal-assistant       # home agent — whose Tasks tab this lives on
model: claude-sonnet                 # default model for every step…
run_message: The topic to dig into.

steps:
  - title: Research the topic
    model: claude-opus               # …but this step gets the heavy model
    prompt: |
      Research {input} thoroughly using web search and reading pages.
      Gather the key facts, the main players, and the open questions.
      Cite sources.

  - title: Scan competitors
    # no model here → falls back to the routine-level claude-sonnet
    prompt: |
      Based on the research below, find how our main competitors handle
      this and where the gaps are:
      {previous}

  - title: Write the summary
    model: gemini-flash              # cheap + fast for the easy last step
    prompt: |
      Summarize everything below into five tight bullets and one
      "so what for us" line:
      {previous}

Three things this shows:

{input} is the run message (what you type in the Run box, or the run_message default). {previous} is the previous step's output — that's how each step builds on the last.
model works at two levels. A routine-level model sets the default for every step; a step-level model overrides it just for that step.
First match wins: the step's own model → else the routine's model → else the model that agent is set up with → else that agent's built-in default. A routine with no model anywhere tracks whatever model you've given the agent, so changing the agent's model changes its routines too.

3. Let Claude or Codex map steps to different Agents too

Model isn't the only per-step knob — each step can run on a different agent. A step's archetype picks who runs it; omit it and the step uses the routine's home agent. Model and agent are independent, so you can, say, run a catalog step on the Sales Platform Wizard while a research step runs on the Personal Assistant:

yaml

  - title: Pull our prices
    archetype: platform-assistant    # the Sales Platform Wizard, good with your catalog
    prompt: List our current products and prices from the connected catalog.

  - title: Compare on the web
    archetype: personal-assistant    # good at web research
    model: gpt-5
    prompt: |
      Compare these against competitors online:
      {previous}

The coding agent can name an Agent by slug or display name. It should use the effective inventory; commonly available built-ins include:

Slug	Display name
`personal-assistant`	Personal Assistant
`platform-assistant`	Sales Platform Wizard
`bulk-text-worker`	Bulk Text Worker
`content-director`	Content Director
`site-builder`	Site Builder

4. Validate, save and check readiness

The coding agent calls validate_routine until valid: true. Review its full canonical YAML, the resolved Agents/models, and the conservative call estimate. Approve create_routine or update_routine only after that review, then inspect get_routine_readiness for blockers and warnings.

5. Check the card says what you expect

Back on the Tasks tab, the routine card's "Runs on…" line reflects the model each step actually uses — so when you've pinned models, that's what shows, not the agent's default. It's your at-a-glance confirmation the pins took.

Preview it before you schedule or trigger it

Separately approve start_routine_dry_run, then compare quality and spend in routine history. The preview calls the selected models and runs the real graph, but removes all tools. For this research example it tests prompt hand-offs and model quality, not web access.

Run one narrow live topic in MyChatBot before automation. When quality and cost look right, ask Claude or Codex to stage a disabled schedule or trigger, then review and enable it separately.

Billing follows the model you pick

A heavier model costs more per step; a lighter one costs less. Each step bills on whatever model it ran on — so pinning a cheap model on the bulk step is exactly how you keep a frequently-run routine affordable. See Usage & billing.

Make it yours

Pin the whole routine, not the steps. If every step should run on one non-default model, set a single routine-level model and skip the per-step ones.
Stop early when there's nothing to do. Add an early_exit so a routine that finds no work bails out gracefully instead of burning steps — see Early exits.
Separate external effects. Model choice does not change authorization. Keep sends, publications and live record changes out of an enabled routine until their effect boundary is tested; approval pauses are currently off by default.

Give each routine step the right model ​

The idea in one table ​

Steps ​

1. Ask Claude or Codex to inspect models and Agents ​

2. Review the routine with per-step models ​

3. Let Claude or Codex map steps to different Agents too ​

4. Validate, save and check readiness ​

5. Check the card says what you expect ​

Preview it before you schedule or trigger it ​

Make it yours ​

See also ​