# How to send quick coding tasks to a cheaper model

AutoRouter · Oct 23, 2026 · 8 min read

Commit messages, renames and one-line shell commands don't need the model you debug with. At list prices on October 22, 2026, Claude Haiku 5.5 costs a fortieth of Claude Opus 5.5 per uncached token on prompts up to 100,000 tokens, and GPT-6 Luna costs a hundredth of GPT-6 Astra, so the example quick turn below costs about 14 cents on Opus 5.5 and about a third of a cent on Haiku 5.5. You can send those turns to a small model yourself with a subagent, a one-off command or a profile. AutoRouter, the Mac app for Codex and Claude Code, does it on every turn: it sends quick tasks to the cheapest capable model, which is often your ChatGPT or Claude plan or a low-cost open model.

## What does a quick turn cost on a frontier model?

A quick turn that sends 30,000 input tokens and gets 1,000 output tokens back costs about 14 cents on Claude Opus 5.5 and 35 cents on GPT-6 Astra at list prices on October 22, 2026, against about a third of a cent on Claude Haiku 5.5 or GPT-6 Luna. Those sizes, with no cache hits, are an assumption for the arithmetic. A commit-message turn carries the agent's system prompt, tool definitions and the diff, and thinking tokens bill as output. Each cell below is tokens times the published price per million.

Inside a long session a frontier turn costs more, because every request also re-sends the conversation so far, which Claude Code reads from the prompt cache at $0.20 per million tokens on Opus 5.5 as of October 22, 2026. DeepSeek V4.1 Flash, the open-weight model in the table, is released under the MIT License; DeepSeek's API charges twice as much from 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays.

## Which tasks are quick enough for a small model?

A task is quick when the right result is clear before the model starts: a commit message for a staged diff, a rename, a one-line shell command, a lint fix, a summary of a log. The model makers draw the same line:

• - Anthropic's pricing guide says to choose Haiku for simple tasks, Sonnet for most production workloads and Opus for the most complex reasoning.
• - Claude Code's cost guide reserves Opus for complex architectural decisions or multi-step reasoning and suggests model: haiku for simple subagent tasks.
• - OpenAI's Codex models page describes GPT-6 Luna as its most efficient model for focused, high-volume tasks, including summarization, extraction and focused coding.

Anthropic's Claude Code best practices give a test for skipping the plan that works here too: if you could describe the diff in one sentence, the task is small. Keep unclear requests, bugs that cross services and tasks that grow harder on the larger model. Whether a cheaper model holds up on the rest is its own question, answered in Does model routing make your results worse?

## How do you send quick tasks to a cheaper model in Claude Code?

Run them in a subagent or a one-off command on Haiku, and leave the main session's model alone. Each model keeps its own prompt cache, so after a /model switch the next request re-reads the whole conversation with no cache hits, while a subagent starts its own conversation and leaves the parent's cache intact.

One-off from the shell. Pipe the diff into print mode with the haiku alias, then commit with the message it prints:

```bash
git diff --staged | claude -p --model haiku "Write a one-line commit message for this diff"
```

A Haiku subagent for commits. Save this as .claude/agents/committer.md (subagent docs) and ask Claude to use the committer subagent when you're ready to commit:

```markdown
---
name: committer
description: Writes a commit message for staged changes and commits them. Use for routine commits.
tools: Bash, Read
model: haiku
---
Run git diff --staged, write a one-line commit message that says what changed, and commit. Don't edit files.
```

A session of small jobs. For an hour of renames and cleanups, start on the small model with claude --model haiku instead of switching partway through a long conversation.

## How do you do the same in Codex?

Run quick jobs as a separate codex exec call on GPT-6 Luna, or keep a profile that sets it as the model. OpenAI's Codex models page documents -m for a single run and /model for switching inside the CLI:

```bash
codex exec -m gpt-6-luna "Write a one-line commit message for the staged changes"
```

For a reusable setup, Codex 0.134.0 and later reads each profile from its own file. Save this as ~/.codex/quick.config.toml and start quick sessions with codex --profile quick:

```toml
model = "gpt-6-luna"
```

Done by hand, you sort every task yourself, and a task that grows harder stays on the small model until you move it.

## How does AutoRouter send quick tasks to a cheaper model?

AutoRouter, the Mac app for Codex and Claude Code, works out how hard each turn is and sends quick tasks to the cheapest capable model, which is often your ChatGPT or Claude plan or a low-cost open model. A model has to clear the quality bar for the task before its price counts, and your own rules decide a turn before any of that; How AutoRouter picks a model for each turn walks through the full order. You choose AutoRouter once, from the model menu in Codex or with /model in Claude Code. It works with Codex (the app and the CLI) and the Claude Code CLI on macOS 14 or later, and it is in beta.

• - A commit message is the landing page's quick-task example. In it, a low-cost open model writes the message and the plan isn't touched. The example is an illustration; real routes follow your plans and rules.
• - Unclear work is never treated as a quick task. A task that continues keeps its model, or moves up, and untested models are never picked on their own.
• - Your rules come first. Write them in plain English, such as sending git commands to a low-cost model, and see how often each rule is used.
• - Every turn shows its model, what it cost and why. AutoRouter sometimes misjudges how hard a task is. When a pick falls short, rate it or choose a model yourself: choosing a model in the picker sends turns straight to it, and AutoRouter routes only while it is the model selected.

Routing across your ChatGPT and Claude plans is free on AutoRouter's Free plan, at $0 a month. Pro costs $20 a month with $20 of included usage each month and adds every other model, billed at the provider's price plus 10%, from the included usage first and then from credits you top up. New accounts get Pro free for their first month, or until $20 of usage is spent, whichever comes first. AutoRouter wrote this post. It earns the 10% on paid models and nothing on your plans, and price only decides between models that already clear the quality bar.

## How much further does a plan go when quick turns move off it?

In the example week on AutoRouter's landing page, as of October 22, 2026, the Free plan does 1.9× the work of using a frontier model for everything, and AutoRouter Pro does 2.9×. That week is an illustration. It isn't a promise or a measurement of your work.

Your own split will differ. For what else stretches a plan, see How Claude Code usage limits work, and how to make them last.

## Questions

### Can I lower the effort instead of changing the model?

Lowering effort helps, but every token still bills at Opus 5.5's $4 input and $20 output per million tokens as of October 22, 2026. Claude Code's cost guide suggests a lower /effort for simpler tasks, which cuts thinking tokens. On Opus 5.5, Sonnet 5.5 and Haiku 5.5 with an API key or a Claude subscription, changing effort keeps the cache.

### Will a small model write worse commit messages?

Sometimes, and a commit message is easy to check before you push: read it, and rerun the task on a larger model when it misses. In AutoRouter, rate the pick or choose the model yourself.

### Do quick turns on Haiku still use my Claude plan?

Yes, when they run in Claude Code on your Claude plan. Anthropic's pricing page says how much you can do depends on the length and complexity of your conversations and the model you choose. AutoRouter sends your plans the work that needs them, so the plans last longer.

### How many of my turns are quick?

It depends on your work, and the 25% in AutoRouter's example week is part of an illustration. In Claude Code, /insights writes a report on what you work on across recent sessions, and AutoRouter shows which model handled each turn, what it cost and why.

### What happens when my plan runs out?

When a ChatGPT or Claude plan hits its limit, AutoRouter Pro keeps those turns going from the monthly usage until the plan resets. If that runs out too, AutoRouter asks you to top up. Credits you buy never expire.

## Sources

• - Pricing, Claude Platform docs, Anthropic
• - Plans and pricing, Anthropic
• - API pricing, OpenAI
• - Models in Codex, OpenAI
• - Advanced configuration, Codex docs, OpenAI
• - Models and pricing, DeepSeek API docs
• - DeepSeek-V4.1-Flash model card, Hugging Face
• - Manage costs effectively, Claude Code docs
• - How Claude Code uses prompt caching, Claude Code docs
• - Create custom subagents, Claude Code docs
• - CLI reference, Claude Code docs
• - Best practices for Claude Code, Claude Code docs