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 the model you pick: a strong model for the step that needs real reasoning, a lighter, cheaper one for the bulk step. You'll do it in the built-in YAML editor on the agent's Tasks tab, using the model field from the Routine YAML reference.
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.

You don't have to touch YAML to get this

You can also just tell your Personal Assistant: "make a routine that researches a topic on a strong model, then summarizes it on a cheap one." It writes the same thing. This guide is the hands-on path — open the editor and pin the models yourself — for when you want exact control.

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 model (`claude-opus`, `gpt-5`)	Worth the cost where quality compounds
Bulk drafting, reformatting, summarizing	A light model (`gemini-flash`, a mini)	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. Open the YAML editor on an agent's Tasks tab

Open Agents → open the agent that should own this routine (your Personal Assistant is a fine home) → its Tasks tab. Then either:

Start fresh: click + New routine. It seeds a starter template already homed on this agent — you'll overwrite it.
Edit an existing custom routine: click its Edit button. (Built-in routines have no Edit button — that's how you know they're read-only.)

The editor is a real text editor with syntax highlighting and inline errors. It scrolls top-to-bottom: your YAML first, then the Automations panel, then Save.

The inline routine editor — the spec YAML up top, Automations panel below

2. Write the routine with per-step models

Here's a complete, valid three-step routine — research on a strong model, a competitor scan on a mid model, and a cheap final summary. Paste it in and adjust:

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

  - 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 step agent's default. A routine with no model anywhere behaves exactly as it always did.

3. (Optional) Send a step to a different agent, 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}

Name an agent by its slug or its display name. The commonly available ones:

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. Save — and let it validate

Press Save. MyChatBot validates the whole spec at once:

Valid → the routine is saved and the card refreshes.
Invalid → a red "This routine has problems:" box lists every problem together (an unknown model alias, a model that can't use tools, a step that references a missing agent), and the editor stays open with your text intact. Fix and Save again.

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.

Sample it before you schedule or trigger it

Press Run on the card, send a topic, and watch the steps tick off in the live activity panel — each step's per-step model is what bills it, so this first run is also your cost check. When the output and the spend look right, wire it to a schedule or a trigger from the Automations panel right below the editor.

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.
Gate the step that acts. Any step that sends, publishes, or changes live data needs an approval gate — add approval: true to it.
Prefer chatting? Everything here is describable in plain language to your Personal Assistant, which writes the same YAML. Open the routine's ⋮ → Edit with assistant and say what should change.

Give each routine step the right model ​

The idea in one table ​

Steps ​

1. Open the YAML editor on an agent's Tasks tab ​

2. Write the routine with per-step models ​

3. (Optional) Send a step to a different agent, too ​

4. Save — and let it validate ​

5. Check the card says what you expect ​

Sample it before you schedule or trigger it ​

Make it yours ​

See also ​