Which AI model to use for a task so you don’t overpay for tokens

In short: let a powerful model do the thinking, and a simpler model do the execution. Give the plan and complex decisions to a flagship model (GPT-6 Astra, Claude Fable 5.1, or Claude Opus 5.5), work from a finished plan to a mid-tier model, and routine tasks and background agent calls to the cheapest model that can handle them. At the same time, check the result: the cheaper the model, the more carefully you need to review its work; otherwise, the savings disappear in rework.

Below is a “task → model” table as of September 23, 2026. The main models in it are personal choices based on work experience. No comparative test was conducted for this table, and the same results are not guaranteed for other tasks. I selected most of the cheaper options based on public rankings and the developers’ own recommendations; Opus 5.5 for code is also based on my experience. The prices were checked against the official OpenAI and Anthropic pages as of 23.09.2026.

For additional instructions on working with Ailoot, see the documentation.

Why using one model for everything is expensive#

If you pay for tokens through an API, every task run on a flagship model costs the flagship price, even when a simpler model would have been enough. With a subscription, take your plan’s and chosen model’s limits into account: check them on the plan page. For a look at how Claude subscription limits work and what uses them up, see the separate article How not to burn through Claude Code limits in a day. This article is about choosing a model for a specific job.

Official API prices per 1 million tokens as of 23.09.2026:

Consider a hypothetical agent run: 100 thousand input tokens and 10 thousand output tokens. This is a calculation example using base prices without caching, not a measurement of a real task. Such a run costs about $1,5 on GPT-6 Astra or Fable 5.1, $0,6 on Opus 5.5, $0,3 on Sonnet 5 or GPT-6 Sol, $0,15 on Haiku 4.5, and $0,015 on GPT-6 Luna. In this calculation, the flagship model and the cheapest model differ in price by a factor of one hundred. For details on calculating such a run using your own volumes, see How to calculate API token usage.

Two notes about prices. For GPT-6 models, requests with more than 272 thousand input tokens are billed at a higher rate in their entirety: input at twice the rate, output at one and a half times the rate. Batch requests are half the standard price at both OpenAI and Anthropic.

The rule: think with a powerful model, execute with a cheap one#

Further work depends on the plan, so I don’t skimp on it and use the most powerful model. A simpler model can write from a finished plan, collect data, rename chats, and compress conversations.

I also follow three other rules when choosing a model:

1. The cheaper the model, the more carefully you need to check its work. Reviewing it takes your time too.
2. Compare the price of a finished result, not a single request. For example, Opus 5.5 is 2.5 times cheaper than Fable 5.1 for both input and output. If rework makes Opus use three times as many input and output tokens for a task, it ends up costing more. Your review time is an additional cost on top of the tokens. The article Which AI agent is cheaper: the cost of one solved task explains how to calculate the cost of a result.
3. If a model doesn’t suit you, try another. There is no single winner; each has its strengths and limitations.

Choosing a model is one part of working with an AI agent.

Table: task → model#

In the “main” column are the models I use myself. The next column lists alternatives, most of which were selected based on public rankings and developers’ recommendations. I also choose Opus 5.5 for code based on personal experience. Check the results of a cheaper model more carefully. The routine options use different payment schemes, so this choice won’t necessarily cost less.

Strategy and plans. An error in the plan can carry over into later steps. Here I use the most powerful model. GPT-6 Sol is a cheaper option: OpenAI positions it for complex code and agent scenarios.

Code. I use Fable 5.1 for code. But Anthropic recommends starting with Opus 5.5 for most tasks, and using Fable 5.1 for difficult reasoning and long-running agent work, or when Opus with high-level reasoning can’t handle the task. Through the API, Opus 5.5 costs 2.5 times less; in my experience, working with it also costs less. If the plan is ready, a cheaper model can write from it. For a detailed comparison of the two flagship models for code, see GPT-6 Astra or Claude Fable 5.1: which should you choose?.

Writing. If a text is intended for a client, I use a powerful model. Sonnet 5 is a cheaper option: Anthropic calls it the best balance of speed and intelligence. Review its output more carefully.

Numbers and finance. Here, too, I use a powerful model. This is my choice based on work experience, not the result of a comparative test. But even a powerful model doesn’t eliminate the need to check: verify figures against the primary source. Don’t send financial or personal data to free plans whose terms allow your data to be used.

Search and research. I use Sonnet 5 for simple tasks and search; that’s based on my experience. GPT-6 Luna is a cheaper option: OpenAI positions it for high-volume repetitive tasks.

Routine tasks. Routine tasks are repeated often, so the costs of individual runs add up. I use Kimi K3 with a Kimi Code subscription. DeepSeek Flash is an option with API-based billing. These are different payment schemes, and which costs less depends on your volume.

Where I don’t skimp#

These rules are based on my practice. I haven’t tested them through a comparative study.

• Planning and architecture. An error in the plan can carry over into later steps.
• Numbers and finance. Here I use a powerful model and still verify figures against the primary source.
• Checking the result. The cheaper the model that did the task, the more carefully you need to check its work.

Conversation compression determines what an agent remembers from a long conversation, and an overly weak model may lose important information. You can move compression to a cheap model, but check its quality on your own tasks.

How to move Hermes Agent background tasks to a cheap model#

In addition to its main work, an agent performs auxiliary tasks: coming up with chat titles, compressing long conversations, analyzing images, and deciding whether a command can be approved automatically. In Hermes Agent, these are labeled auxiliary. By default, each is set to auto: your main model handles it. If the main model is a flagship and you pay through the API, auxiliary tasks are also billed at the flagship rate.

For command approval in smart mode, the Hermes documentation recommends a cheap, fast model and calls using expensive models a waste. For context compression and summarizing web pages—that is, briefly recounting them—it also recommends a fast model instead of an expensive reasoning model.

Steps:

1. Connect a provider for the cheap model in advance, with a key. According to the Hermes documentation, if you assign a provider without a key to a task, it will fall back to the default option, and a warning will be written to the agent.log log. In auto mode, if the main model can’t perform the task and no fallback chain is configured, Hermes will skip the task with a warning and won’t switch to other connected providers.
2. Open the Hermes web panel and follow Models → Model Settings → Auxiliary tasks → Configure. On the row for the task you need (for example, Compression, Title Gen, Vision), click Change, choose a provider and model, then click Switch. The Hermes documentation lists a Show auxiliary button for this instead; the labels depend on the version.
3. Or enter the same settings in ~/.hermes/config.yaml. Example from the Hermes documentation: image analysis (vision) with a fast model.

auxiliary:
  vision:
    provider: <your-provider>
    model: <fast-model>

For chat titles, the documentation suggests pinning a fast model or setting auxiliary.title_generation.prefer_fast_model: true, and Hermes will select a fast model from your provider.

4. Open a new session. Model changes apply only to new sessions; chats that are already open continue using the old settings. If you edited config.yaml manually and a new session didn’t pick up the setting, restart Hermes.

How to check. The task row should show provider · model instead of auto (use main model). If it still says auto, the task is still using the main model. To return all tasks to the main model, click Reset all to auto.

For background tasks, the table lists GPT-6 Luna, Gemini 3.8 Flash, DeepSeek Flash, and Claude Haiku 4.5. Choose from providers you already have connected. If you connect OpenAI models through a ChatGPT / Codex subscription provider, and GPT-6 Sol and GPT-6 Luna aren’t yet listed among your Hermes models, the table recommends GPT-5.6 Sol or GPT-5.6 Luna. According to the Anthropic page, Haiku 4.5 will be retired no earlier than October 15, 2026. There is no exact date, so check its status before then.

What the table doesn’t include#

• Savings percentages. I haven’t measured them. How much you save depends on your tasks and the models you choose.
• Exact subscription limit usage. The Hermes documentation doesn’t describe exactly how requests from Hermes use ChatGPT subscription limits.
• Prices that never change. Models and plans change. Check the official pages before buying.

What to do today#

1. List three or four types of tasks you most often give your agent.
2. For each, decide: does it need to think, or execute a finished plan?
3. Keep a flagship model for “thinking,” use a model one level down for “execution,” and use the cheapest model that can handle the task for routine work.
4. In Hermes, start with chat titles: they’re the easiest to move to a cheap model. Move context compression next, and check on your own long conversations whether the agent has started losing important information.

For more work with models, go to Ailoot.