Cheapest LLM for AI Agents: 30 Models Ranked by Cost Per Run

The cheapest model that will run a tool-calling agent is DeepSeek V4 Flash at $0.05 in / $0.16 out per 1M tokens, or $0.0089 for a reference 12-step run. The cheapest model we would run unattended in production is Gemini 3.8 Flash ($0.75 / $3.75) or GPT-5.4 mini ($0.75 / $4.50) at about $0.14 per run. The cheapest flagship-class model is Claude Sonnet 5 ($2 / $10) at $0.37. Prices are USD per 1M tokens from our catalogue as of 2026-09-11.

The reference run: a 4,000-token system prompt plus tool definitions sent every step, a 1,500-token tool result appended after each step, 300 output tokens per step, 12 steps. Because each step re-sends the full history, the context at step k is 4,000 + (k - 1) × 1,800 tokens, and the run totals:

• Input tokens = 12 × 4,000 + 1,800 × 12 × 11 ÷ 2 = 48,000 + 118,800 = 166,800
• Output tokens = 12 × 300 = 3,600
• Run cost = 166,800 × (input rate ÷ 1,000,000) + 3,600 × (output rate ÷ 1,000,000)

For Claude Sonnet 5: $0.3336 + $0.036 = $0.3696. Input is 90% or more of the run on every model, so the ranking tracks the input price. The general formula for N steps is in how much does an AI agent cost to run.

No caching or batch discounts applied. Multiply the last column by 1,000 for a monthly budget at 1,000 runs.

The spread from rank 1 to rank 29 is 106×. Prompt caching narrows it without reordering it: with cache reads at roughly 10% of list on Anthropic and OpenAI and roughly 25% on Gemini, Sonnet 5 falls to about $0.12 and Gemini 3.8 Flash to about $0.06 per run. Live rows are on the models page.

Price is the easy half. An agent model has to emit a tool call that matches the schema, pick the right tool, stop when done, and not loop. The tiers below are our editorial reading of how much scaffolding each model needs in a production loop, not a benchmark; run your own eval on your own schemas before committing.

• Tier A, run unattended with normal validation: Claude Opus 5, GPT-5.5, GPT-5.4, Gemini 3.1 Pro, Claude Sonnet 5. Consistent schema adherence, good stopping behaviour, fewest wasted steps.
• Tier B, run unattended with strict schemas: Claude Haiku 4.5, GPT-5.4 mini, Gemini 3.8 Flash, GPT-5.3-Codex and Devstral 2 (coding loops), DeepSeek V4 Pro, Kimi K2.6, Qwen 3.8 Max, Grok 4.6, Mistral Large 3.
• Tier C, run with validation, retries and an escalation path: GPT-5.4 nano, Gemini 3.5 Flash Lite, DeepSeek V4 Flash, DeepSeek V4.1 Flash, GLM 4.7, MiniMax M2.7, Qwen3 Coder 480B, Llama 4 Maverick, Codestral 2508, Mistral Medium 3.1. Expect malformed arguments, wrong tool choices on large tool sets and step-count blowouts on open-ended tasks.
• Tier D, not as the planner: Llama 4 Scout, GLM 4.7 Flash, GPT-4.1 mini (previous generation). Fine for single-shot classification inside a loop someone else drives.

The cheapest model that still does this reliably is Gemini 3.8 Flash or GPT-5.4 mini at about $0.14 per run, with Claude Haiku 4.5 at $0.185 as the Anthropic equivalent. Below $0.10 per run you are buying a model that needs a supervisor, and the supervisor's cost belongs in your per-task number.

The cost-per-task winner is almost never a single model. It is a Tier C or B model as the first attempt, a validator that checks the tool call and the final result, and a Tier A model that takes over only when the cheap attempt fails. One OpenAI-compatible client through OpenRouter makes the ladder a list of model names (see our OpenRouter vs direct API comparison for the routing margin).

from openai import OpenAI
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=KEY)

LADDER = [  # (model, $ in per 1M, $ out per 1M)
    ("deepseek/deepseek/deepseek-v4-flash", 0.05, 0.16),
    ("google/gemini-3.8-flash", 0.75, 3.75),
    ("anthropic/claude-sonnet-5", 2.0, 10.0),
]

def run_task(task, max_steps=12, budget_usd=0.60):
    spent = 0.0
    for model, p_in, p_out in LADDER:
        history = [{"role": "user", "content": task}]
        for _ in range(max_steps):
            r = client.chat.completions.create(model=model, messages=history,
                                               tools=TOOLS, max_tokens=2000)
            u = r.usage
            spent += (u.prompt_tokens * p_in + u.completion_tokens * p_out) / 1e6
            if spent > budget_usd:
                return None, spent                # hard cap: give up
            ok, done = apply_tool_calls(r, history)   # validate + execute
            if not ok:
                break                             # schema/tool failure: escalate
            if done and validate_result(history):
                return history[-1], spent         # success on this rung
    return None, spent

validate_result must be a cheap deterministic check that the task is actually finished (tests pass, the record exists, the JSON matches), and spent is shared across every rung. Without a validator, the ladder just launders failures upward.

Cost per successful task = cost per run ÷ success rate, plus the escalation or retry cost when the run fails. A worked example with illustrative success rates (replace them with your own eval numbers):

Routing beats every single-model strategy on API spend. Three things push the flagship back into the lead. Failure cost: if a failed run needs a person to notice and rerun it, a 55% first-attempt failure rate costs more in minutes than the routing saved in dollars. Step count: a cheap model that takes 30 steps ($0.293 on Gemini 3.5 Flash Lite) to do what Sonnet 5 does in 12 ($0.37) has thrown away its advantage. Side effects: when a wrong tool call sends an email or writes to production, the validator cannot undo it.

When to pay for the flagship: as the planner in a multi-agent system, on any step with irreversible side effects, and whenever a failed run costs more than about $0.50 in someone's time. When not to: on the routine majority of steps, where Tier B at $0.14 with strict schemas is the right default.

Every agent loop needs four limits regardless of model:

• max_tokens per call of 1,000 to 4,000 for tool-calling turns.
• A hard step cap, 12 to 15 for most task types, in your loop or via the SDK's turn limit.
• Stop conditions: a required finish tool, an abort on repeated identical tool calls, and an abort on two consecutive tool errors.
• A per-run USD budget computed from the usage object after every call, shared across escalation rungs as in the snippet above.

Sensible per-run ceilings: about $0.10 for a Tier C loop, $0.30 for Tier B, $1.00 for Tier A, and $2.00 for a run allowed to escalate all the way. The AI cost calculator converts a monthly run count into a budget line, and the Claude agent API cost, OpenAI Agents SDK cost and Gemini agent API cost guides cover vendor-specific caps and caching syntax.

Cheapest model that runs an agent at all: DeepSeek V4 Flash at $0.009 per 12-step run. Cheapest we would run unattended with strict schemas: Gemini 3.8 Flash or GPT-5.4 mini at about $0.14, Claude Haiku 4.5 at $0.185 on Anthropic. Who should pay flagship rates on every step: teams whose tool calls have side effects or whose failures cost real time. Who should not: anyone with a validator and a routine task mix. Cheapest way to get the result: caching first, Tier B by default, a Tier C first attempt behind a validator, and a shared per-run budget.