Cheapest LLM APIs for AI Agents: 2026 Price Table

The working guide to the cheapest LLM APIs that are actually good enough to run AI agents in 2026.

The price of a GPT-3-quality answer fell from $60 per million tokens in late 2021 to about $0.06 by late 2024, a 1,000x collapse in three years - Andreessen Horowitz. At the same time, the thing you actually build with those tokens changed shape. A chat request is one call in, one answer out. An AI agent is a loop: it re-sends its whole growing transcript on every step, calls tools, spawns sub-agents, and thinks in hidden reasoning tokens you still pay for. Anthropic's own engineering team measured that agents burn roughly 4x the tokens of a chat interaction, and multi-agent systems burn about 15x - Anthropic Engineering.

Here is the problem that trap creates: the cheapest API on a pricing page is almost never the cheapest way to run an agent. A model that looks twice as expensive per token can be far cheaper per completed task if it caches your system prompt, calls tools reliably on the first try, and finishes in fewer steps. Meanwhile a "cheap" nano model that fails a tool call and loops three extra times can quietly cost more than a frontier model that gets it right once. The sticker price and the real bill diverge, and for agents they diverge a lot.

This guide fixes that. It lays out the real 2026 price table across every serious provider, translates raw per-token numbers into what agents actually pay, and shows the specific levers (prompt caching, batch processing, model routing, off-peak scheduling, context compaction) that move an agent's bill by 10x without changing a single model choice. We start high level with how pricing works, then go tier by tier from ultra-cheap nano models up through the cheap-frontier contenders, then into the open-weight hosting layer and the gateways that route between all of them. Managed platforms like o-mega sit at the far end of this spectrum, hiding the token math entirely behind an agent workforce, and we treat that as one option among many.

Every price in this guide was verified against provider pricing pages or authoritative trackers as of late August 2026. Because this is the fastest-moving cost line in software, treat exact numbers as time-stamped snapshots, not permanent facts.

Contents

1. Why the sticker price is the wrong number
2. How LLM API pricing actually works in 2026
3. The great price collapse (and why agents ate the savings)
4. The 2026 master price table for agents
5. The weighted ranking: cheapest models that can still run agents
6. The ultra-cheap nano tier
7. The cheap tier: real work under a dollar
8. The mid tier: near-frontier quality without frontier bills
9. The frontier tier and the rise of cheap-frontier
10. The open-weight hosting layer
11. Gateways, routers, and the arbitrage layer
12. The seven levers that actually cut agent cost
13. Real per-task cost math
14. How AI agents are reshaping the pricing field
15. Where cheap wins and where it fails
16. The future outlook for agent economics
17. Conclusion: a decision framework

The weighted ranking at a glance

Before the detail, here is the whole field scored on what an agent builder actually cares about. This table ranks representative models and hosted options on a cost-weighted rubric, so it deliberately rewards models that are cheap, fast, and cache-friendly over models that are simply the most capable. A frontier model that lands low here is not "bad," it is expensive relative to how often an agent needs its full intelligence. Read this as "cheapest thing that can still do the job," not "best model overall."

The criteria, and why these four: Cost (35%) is the blended input-plus-output price for a symmetric workload, because that is the number that scales linearly with agent volume. Agent capability (25%) captures tool-calling reliability and multi-step reasoning, because a failed tool call re-runs the whole loop and erases any per-token savings. Cost control (20%) rewards caching economics, batch discounts, and off-peak pricing, because those levers routinely move the real bill more than the model choice does. Context and speed (20%) matters because a small context window forces expensive compaction and slow throughput lengthens every multi-step task. The order this produces is the honest one: for most agent work you do not need Opus-class intelligence on every step, so the cheap, fast, cacheable models win the cost-efficiency contest even though they lose the raw-capability one. We cover the reverse case (when capability has to win) in section 15.

1. Why the sticker price is the wrong number

Start from first principles. An LLM API is stateless. The model remembers nothing between calls, so to continue a conversation you resend the entire history every single time. For a chatbot, that history grows slowly and the last answer is the product. For an agent, the history is the product's scaffolding, and it grows fast: a system prompt, a block of tool definitions, and then a lengthening record of every tool call and every tool result the agent has accumulated on its way to an answer. A twenty-step tool loop re-bills the accumulated context up to twenty times. This is why a single agent task can push 400,000 to 2,000,000 cumulative input tokens through an API even when the final answer is a paragraph - Liatrio Labs.

That structural fact reframes the entire question. When people ask "which LLM API is cheapest," they are usually comparing per-token prices as if the token count were fixed. It is not. The token count is a function of the model and the architecture, not just the price list. A model that follows instructions precisely and calls tools correctly finishes in fewer steps, which means fewer re-sends of a growing context, which means a smaller bill even at a higher per-token rate. A cheaper model that hallucinates a malformed tool call forces a retry, and each retry re-sends the whole context and generates a fresh completion. The retry, not the token price, is where the money goes. We unpacked this dynamic in depth in our analysis of the true cost of LLM inference in 2026, and it is the single most important idea in this guide.

There is a second reason the sticker price misleads, and it is about output. Output tokens cost three to five times more than input tokens on almost every provider, and reasoning models emit hidden "thinking" tokens billed at the output rate before the visible answer even begins. OpenAI's o-series models are the clearest example: a request can emit three to ten times the visible output in internal reasoning, so the effective cost per turn is far above what the base rate implies - CloudZero. An agent that reasons on every trivial step pays this tax constantly. The lever, which we cover later, is to dial reasoning effort down for easy steps and reserve it for genuinely hard ones, an approach we detailed in our guide to setting the effort dial to cut AI costs.

So the correct question is not "what is the cheapest API?" It is "what is the cheapest path to a completed task?" That path depends on the model, the caching setup, the routing logic, and how much context the agent drags around. The rest of this guide answers the real question, starting with the mechanics of how modern pricing actually works.

2. How LLM API pricing actually works in 2026

Every serious LLM API in 2026 prices along the same handful of axes, and understanding them is the difference between a $50 monthly bill and a $500 one for identical work. The first axis is the input/output split. You pay one rate for the tokens you send (the prompt) and a higher rate for the tokens the model generates (the completion). Because agents send enormous prompts (the whole re-sent transcript) and often produce short structured answers, agent economics are usually input-dominated, which flips a lot of intuition: a model with a cheap input rate and an expensive output rate can be a bargain for tool-calling agents even though it looks costly for chat.

The second axis is cached input. Nearly every major provider now lets you cache a stable prefix (your system prompt plus tool definitions) so that subsequent calls pay a small fraction of the input rate for those repeated tokens. Anthropic charges cache reads at 10% of the input rate, OpenAI applies an automatic 90% discount on cached reads, and Google's context caching drops Gemini reads to as little as $0.025 per million on the Flash-Lite tier - Google. Cache writes cost slightly more than a normal read (typically 1.25x the base input rate), so caching pays for itself after roughly two reads - Finout. For an agent that resends a fat static prefix on every one of a loop's many steps, this is the single largest cost lever in the entire stack, and we return to it in section 12.

Beyond those two, four more axes shape the real bill:

• Batch processing gives a flat 50% discount on both input and output for non-interactive jobs returned within a day, offered by Anthropic, OpenAI, and Google - TokenMix.
• Long-context surcharges kick in on several models once a single request crosses a threshold, and they apply to the whole request, not just the overflow.
• Off-peak discounts are newest: DeepSeek now bills roughly half price outside two narrow peak windows each day.
• Reasoning tokens are billed at the output rate and are invisible in your prompt, so they surprise budgets built on visible output alone.

The long-context surcharge deserves special attention because it is a landmine for agents specifically. Gemini 3.1 Pro and every Grok 4.x model roughly double their rates once a single request crosses about 200,000 tokens, and OpenAI's GPT-5.6 family applies a similar 2x input, 1.5x output penalty above 272,000 tokens - OpenAI Developer Docs. The trap is that agents accumulate context naturally, so a long-running loop can silently cross the line and double every token in the request, not just the ones past the threshold. Flat-priced models to a million tokens, like Gemini 3.5 Flash and Flash-Lite, are much easier to budget for exactly this reason. The practical takeaway is that agents should compact their context before they hit these cliffs, a point that connects directly to the caching and compaction levers later in this guide.

3. The great price collapse (and why agents ate the savings)

The backdrop to everything in this guide is one of the steepest cost declines in the history of computing. Andreessen Horowitz coined the term "LLMflation" to describe it: the price of an equivalent-quality token falls roughly 10x per year. Their canonical example is stark. Reaching GPT-3-level quality (about 42 on the MMLU benchmark) cost $60 per million tokens in November 2021 and about $0.06 per million by November 2024, a thousand-fold drop in three years - a16z. For GPT-4-class quality (MMLU around 83), the price fell roughly 62x since the March 2023 launch. Frontier input pricing that sat at $30 per million in early 2023 now clusters between $1.25 and $5 for the top tier.

Here is the twist that matters for this guide: the savings did not shrink anyone's bill. They changed what people build. When intelligence gets cheap, you use vastly more of it, and the agent architecture is the perfect vehicle for consuming the surplus. Google's own numbers make the point at planetary scale: the company processed 9.7 trillion tokens per month in 2024, then 480 trillion by April 2025, and about 3.2 quadrillion tokens per month by May 2026, a roughly sevenfold year-over-year jump - Google I/O 2026, via Gigazine. Enterprise LLM API spend told the same story from the demand side: it more than doubled in six months, from $3.5B in November 2024 to $8.4B by mid-2025, reaching $12.5B for full-year 2025 as workloads moved into production - Menlo Ventures.

The structural lesson is the one we drew out in the big pipe: how LLM inference is eating software. Falling token prices are a tailwind, not a finish line. Each year, a workload that is uneconomic today becomes cheap purely from price compression, which is why teams over-provision on capability now. But the agent architecture's re-sent-context multiplier partially eats that tailwind, so the two forces (prices falling, consumption exploding) run in tension. The teams that win are not the ones waiting for prices to drop. They are the ones who pick a cheap-enough model today and squeeze the architecture, which is exactly what the tier-by-tier sections below equip you to do.

4. The 2026 master price table for agents

Here is the field, priced. This table lists the standard per-million-token rates for the models that matter to agent builders, spanning every tier from ultra-cheap nano up to the frontier. Where a model uses tiered or promotional pricing, the note captures the catch. All figures are verified as of late August 2026 and reflect the input rate, output rate, cached-input read rate, and context window. Read it as a map, not a verdict: the sections after it explain which of these numbers actually apply to your agent's workload.

Two structural traps sit inside this table and both matter more than any single price. The first is the long-context flip on Gemini 3.1 Pro, the Grok 4.x line, and the GPT-5.6 family, where crossing roughly 200,000 to 272,000 tokens in one request multiplies rates across the entire request. The second is promotional pricing with an expiry: Anthropic's Claude Sonnet 5 introductory rate of $2/$10 reverts to $3/$15 on September 1, 2026, and OpenAI's GPT-5.6 Sol promotional short-context rate reverts to standard after November 21, 2026 - CloudZero. A budget built on the promo rates will jump the day they end, so plan for the standard numbers if your agent runs past those dates.

The pattern the table reveals, once you scan it top to bottom, is a 50x spread between the cheapest small-model input token and the most expensive frontier output token. That spread is not a nuisance, it is the opportunity. It is precisely what makes model routing (cheap model first, escalate only when needed) the highest-leverage cost technique in the whole field, and it is the reason no serious agent should run every step on a single flagship model.

5. The weighted ranking: cheapest models that can still run agents

The scoring table at the top of this guide is worth reading closely, because its ordering is counterintuitive on purpose. It does not crown the smartest model. It crowns the cheapest option that can still complete real agent work, which is a different and more useful thing when you are running thousands of agent steps a day. The top of the ranking is dominated by fast, cache-friendly, high-context models: Groq's GPT-OSS 120B, GPT-5.6 Luna, Gemini 3.1 Flash-Lite, and the Grok Fast line. These are not the models that top capability leaderboards. They are the models that do 80% of an agent's steps for a fraction of the cost, leaving the expensive frontier calls for the 20% that genuinely need them.

The rubric weights cost at 35% deliberately, because for a production agent fleet, token spend is the dominant variable cost and it scales linearly with volume. But cost is not the only thing that matters, which is why agent capability carries 25%. A model that is cheap per token but unreliable at tool calling destroys its own savings through retries, so the middle of the ranking is where a model's real agent-worthiness gets tested. This is also why Amazon Nova Micro, despite having the cheapest input price on the entire market at $0.035 per million, lands only at position 12 rather than the top: it is superb for routing and classification but weak at the multi-step reasoning that defines an actual agent - AWS. Cheapest-per-token and cheapest-per-task are not the same ranking, and this table optimizes for the second.

The bottom of the table holds the frontier models, and their low placement needs a caveat that the section 15 discussion expands on. Claude Opus 5 at position 17 is not a poor model. It is the most reliable long-horizon autonomous agent brain available, and on a rubric weighted for raw capability it would sit at the top. It ranks low here only because this table asks a cost-efficiency question, and on a per-token basis Opus 5 is six times the price of Sonnet 5 and roughly fifteen times the price of the nano tier. The honest reading is that you route to Opus 5 for the hard 20% and to the cheap tiers for the easy 80%, which is the central discipline of cost-effective agent building. We compared the two Anthropic workhorses head to head in Claude Opus 5 vs Sonnet 5: which to build on, and the answer there, as here, is "both, routed by difficulty."

One more thing the ranking surfaces: the cheap-frontier phenomenon. Grok 4.6 sits at position 15 with a frontier-level capability score but a mid-tier price of $2/$6, which is why it scores respectably on a cost-weighted rubric where true frontier models sink. That combination (frontier reasoning at Flash-class input pricing) is the most disruptive pricing move of 2026, and it gets its own treatment in section 9.

6. The ultra-cheap nano tier

The nano tier is where the price war is most brutal and where the biggest misconceptions live. These are the models priced under roughly $0.50 per million input tokens, built for the highest-volume, most repetitive agent steps: intent routing, classification, extraction, guardrail checks, and cheap sub-agent fan-out. The mistake builders make is treating nano models as "the whole agent." They are not. They are the workers in an orchestrator-worker pattern, doing the simple, high-frequency steps while a smarter model handles planning. Used that way, they are transformative for cost. Used as the agent's brain, they loop, fail tool calls, and cost more than they save.

The current nano leaders each win a different sub-battle. Amazon Nova Micro owns the absolute price floor at $0.035 input, $0.14 output, a rate so low it is effectively free for text classification, though it is text-only and the weakest reasoner of the group - AWS. Qwen3.5-Flash at $0.10/$0.40 pairs a rock-bottom price with a full million-token context and reliable function calling, and its tiered pricing drops sub-32K prompts to around $0.03/$0.13 - BenchLM. GPT-5.6 Luna at $0.20/$1.20 is the most agent-complete of the tier, retaining OpenAI's full Responses-API tool surface (web search, code interpreter, computer use, MCP) plus automatic 90%-off cached reads, which makes caching-heavy loops astonishingly cheap - OpenAI Developer Docs. Google's Gemini 3.1 Flash-Lite rounds out the group at $0.25/$1.50 with a near-free $0.025 cache-read rate.

For agent builders the ranking within this tier should be:

• Nova Micro for pure classification and routing where reasoning does not matter and the input price dominates.
• Qwen3.5-Flash for the best blend of cheap price, large context, and open-weight self-host escape hatch.
• GPT-5.6 Luna when the nano step still needs reliable tool calling or hosted tools.
• Gemini 3.1 Flash-Lite when you want near-free cached context replay across many parallel calls.

The practical implication of these near-free rates is worth sitting with, because it changes agent architecture. When a classification step costs $0.035 per million tokens, you can afford to run it constantly: on every user message, every tool result, every intermediate state, as a cheap guardrail against the expensive model going off the rails. The nano tier is not just "the cheap option," it is what makes defensive, self-checking agent designs economically viable, because you can spray a cheap verifier across a workflow without the verification cost mattering. This is a genuinely new capability that did not exist when the cheapest usable model cost $1 per million, and it is why the nano tier deserves more architectural attention than its low prices suggest.

7. The cheap tier: real work under a dollar

The cheap tier is the sweet spot for the majority of production agents, and it is the most competitive band of the entire market. These are models roughly between $0.20 and $1.50 input that can do genuine multi-step work: they call tools reliably, follow structured-output schemas, and reason well enough to plan a few steps ahead. This is the tier where "cheap" stops meaning "toy" and starts meaning "good enough to ship," and the 2026 crop is deep. The standout is xAI's Grok 4.1 Fast at $0.20/$0.50 with an extraordinary 2-million-token context window, which effectively removes the need for caching because the agent can simply hold its entire working set in context without compaction - BenchLM.

Alongside it sit several specialists worth knowing by name. Grok Code Fast 1 at $0.20/$1.50 is tuned for coding agents and offers a $0.02 cache-read rate among the cheapest anywhere, so replaying a large repository context across many small edits is nearly free - BenchLM. Gemini 3.5 Flash-Lite at $0.30/$2.50 brings Google's reliability and flat-to-1M pricing. On the open-weight side, GLM-4.6 at a corrected live rate of $0.43/$1.75 remains a favorite in Claude-Code-style coding CLIs for its price-to-quality ratio - PricePerToken, and Mistral Large 3 at $0.50/$1.50 delivered one of the year's biggest price cuts while keeping the strong native function-calling that is Mistral's signature and EU data residency for teams that need it - Mistral.

DeepSeek V4-Flash deserves its own paragraph because it pioneered the pricing mechanic that may define the tier's future: off-peak billing. Its standard rate is $0.44/$1.32, but DeepSeek now charges half price outside two narrow daily peak windows, dropping the model to $0.22/$0.66 for roughly sixteen hours a day - DeepSeek. On top of that, DeepSeek runs automatic disk-based prefix caching that bills cache hits at one-tenth the input rate (about $0.014 at peak, $0.007 off-peak) with no code changes, which is decisive for agent loops that resend a static system prompt on every step. An agent scheduler that batches overnight enrichment work into the off-peak window, with caching on, runs at a fraction of what the sticker price suggests. We ran the full comparison in DeepSeek V4 Flash vs Opus 4.8: the cost math, and the gap in raw token cost is roughly an order of magnitude.

The judgment call in this tier is between the Western hosted models (Grok, Gemini) with their consistency and tooling, and the open-weight challengers (GLM, DeepSeek, Qwen, Mistral) with their lower floors and self-host escape hatch. For a latency-sensitive interactive agent, the Western Fast-line models usually win on predictability. For a high-volume batch agent where the absolute per-token floor is what matters, the open-weight models on their first-party APIs (or self-hosted) win, and the open weights mean you are never locked into a single vendor's price. We surveyed that open-weight landscape in top open-source LLMs in 2026, and it is the fastest-moving corner of the market.

8. The mid tier: near-frontier quality without frontier bills

The mid tier is where agents that need to be genuinely reliable, but cannot justify frontier pricing, should live. These models, roughly $1.25 to $3 input, are the workhorses: strong enough for multi-step planning, orchestration, and code generation, but priced at a third to a half of the frontier. The defining models here are Anthropic's Claude Sonnet 5, OpenAI's GPT-5.6 Terra, and xAI's Grok 4.3, and the choice between them is more about ecosystem and reliability than raw price, because they cluster within a few dollars of each other on a blended basis.

Claude Sonnet 5 is the reliability benchmark of the tier. At its introductory $2/$10 (reverting to $3/$15 on September 1, 2026) it delivers near-Opus quality on coding and agentic work with the most dependable tool-calling in the mid tier, adaptive thinking on by default, and the full effort ladder including the xhigh setting that Anthropic recommends for hard agentic tasks - CloudZero. GPT-5.6 Terra at $2/$12 matches it feature for feature (function calling, structured outputs, reasoning tokens, the whole Responses-API tool surface) at a similar price, and the choice between the two often comes down to which provider's tooling your stack already speaks. Grok 4.3 is the value play at $1.25/$2.50: its output rate is unusually cheap for a capable model, which makes it the best mid-tier choice for verbose agent runs where output tokens dominate, and it carries a full 1-million-token context.

The open-weight labs field strong mid-tier contenders too, and they undercut the Western models substantially. Moonshot's Kimi K3 at $3/$15 is a 2.8-trillion-parameter open-weight flagship with a full 1-million-token context, explicitly built for agents with automatic context caching, tool calling, and configurable reasoning effort - Moonshot. Alibaba's Qwen3.8-Max at $2/$6 (and 60-70% cheaper on the mainland Beijing endpoint) brings strong function-calling and explicit context-cache pricing, though the Max tier is not open-weight. We benchmarked these against the Western flagships in Qwen 3.8 Max vs Claude and GPT for agents and in Kimi K3 benchmarks and cost, and the pattern is consistent: the open-weight mid-tier models trade a small amount of tool-calling polish for a meaningful price advantage.

There is one trap in this tier that catches budgets constantly, and it is OpenAI's o4-mini. On paper it looks like a cheap mid-tier reasoning model at $1.10/$4.40. In practice, because it is a reasoning model, it emits hidden thinking tokens billed at the output rate, and a single request can generate three to ten times the visible output in internal reasoning - CloudZero. For an agent that reasons on every step, the effective per-turn cost can be several times the sticker rate, which pushes o4-mini's real cost above the nominally more expensive Sonnet 5 or Terra for many workloads. The lesson generalizes: for reasoning models, the base rate is a floor, not an estimate, and you should measure the reasoning-token multiplier on your own prompts before you trust the price list.

9. The frontier tier and the rise of cheap-frontier

The frontier tier is where the "cheapest" framing gets tested hardest, because these models are not cheap and are not trying to be. Claude Opus 5 at $5/$25, GPT-5.6 Sol at $5/$30 (promotionally $4/$20 through November 2026), and Claude Fable 5 at $10/$50 are the models you reach for when correctness on a long, autonomous, multi-step task matters more than the token bill - Anthropic. For a coding agent doing an overnight refactor, or a research agent running a fifteen-step investigation where a single wrong turn wastes everything downstream, the frontier models earn their premium by finishing the task correctly in fewer attempts. The false economy is running a cheap model on a task it cannot complete, looping forever, and paying more in retries than a frontier model would have cost outright.

But 2026 introduced a genuinely new category that scrambles the old "frontier means expensive" assumption: cheap-frontier. The clearest example is xAI's Grok 4.6, which delivers frontier-level reasoning and tool calling at $2 input, $6 output for prompts under 200,000 tokens, roughly half the output price of Gemini 3.1 Pro and a fraction of Opus 5 - eesel AI. Independent benchmarks placed it near the top of the Artificial Analysis leaderboard while pricing it like a mid-tier model. We covered its arrival in Grok 4.6: the cheapest frontier LLM for agents, and it forced every other lab to answer the question of why a builder should pay frontier prices for frontier quality when one vendor is offering the latter without the former.

Google's Gemini 3.1 Pro is the other model straddling this line, at $2/$12 for prompts up to 200,000 tokens (flipping to $4/$18 above that), with strong structured-output adherence and a cheap $0.20 cache-read rate that makes multi-turn agent loops with large fixed prompts economical to replay - Google. Between Grok 4.6 and Gemini 3.1 Pro, the frontier floor has effectively dropped to around $2 input, which is a remarkable place for the top of the market to sit given it was $30 in early 2023.

The critical caveat on every cheap-frontier model is the long-context flip. Grok 4.6 and Gemini 3.1 Pro both roughly double their rates once a single request crosses 200,000 tokens, and the doubling applies to the entire request, not just the overflow. For agents, which accumulate context naturally, this is easy to trip. An agent that starts a task at 50,000 tokens and grows to 210,000 over its loop does not pay the higher rate on the last 10,000 tokens, it pays it on all 210,000. The discipline this demands (compact aggressively before the cliff, or pick a flat-priced model like Gemini 3.5 Flash for long-running loops) is the same discipline that governs the entire cost-optimization discussion in section 12. The frontier is cheaper than ever, but only if you stay under the line.

10. The open-weight hosting layer

Underneath the branded APIs sits a layer that agent builders chasing the absolute floor price cannot ignore: the inference hosts that run open-weight models on their own hardware and charge for the tokens. This is where the true price floor lives. Because the weights are free, a dozen platforms compete purely on infrastructure efficiency, and the result is that a capable 70-billion-parameter model now costs around $0.10 to $1.00 per million input tokens, and small models are effectively free. DeepInfra and Novita consistently anchor the bottom: DeepInfra hosts a Llama-family 70B model at $0.10/$0.32 and small 8B models at around $0.02/$0.04, with its cheapest listed model near $0.019 per million - DeepInfra.

The right way to think about this layer is a spectrum from rock-bottom price to enterprise reliability, and where you land depends on what your agent needs. At the floor, DeepInfra and Novita give you the cheapest tokens with solid but not guaranteed throughput. A notch up, Together AI and Fireworks AI add throughput SLAs, dedicated endpoints, and (on Together) a 50% Batch API discount, hosting models like a 235-billion-parameter Qwen3 at $0.20/$0.60 - Together AI. Baseten spans both serverless per-token Model APIs and dedicated per-GPU-minute deployments (with scale-to-zero idle billing) for teams whose agents need guaranteed capacity - Baseten. The through-line is that all of these are OpenAI-compatible with function calling, so an agent written against one host ports to another with a base-URL change.

The most important insight in this layer is not price, it is which open-weight models are actually agent-grade. The floor-price small models (an 8B Llama, a Mistral-Nemo) are cheap precisely because they are weak at multi-step tool calling, so using them as an agent brain is a false economy. The open-weight models that genuinely hold up in agent loops are the larger, newer ones: OpenAI's GPT-OSS 120B, DeepSeek V4, the Qwen3 235B class, and the GLM-5 line. Here is where the two speed-focused hosts change the calculation:

The speed axis that Groq and Cerebras compete on matters for agents in a way that raw price does not capture. Cerebras runs a 70B model at roughly 1,800 tokens per second, ten to twenty times a typical GPU, which collapses the wall-clock time of a long multi-step agent chain - Cerebras. Groq's LPU delivers similar speed advantages while stacking a 50% prompt-cache discount with a 50% Batch API discount for an effective rate around a quarter of on-demand - Groq. For an interactive agent where a user is waiting, or a long tool-calling loop where latency compounds across steps, buying speed can be worth more than buying the cheapest token, because the time cost of a slow agent is real even when it does not show up on the invoice.

11. Gateways, routers, and the arbitrage layer

Sitting on top of every provider and host is a layer that does not run models at all: the gateways and routers. Their job is to give an agent one API key, one endpoint, and automatic failover across dozens of underlying providers, plus the ability to route each request to the cheapest or fastest host that serves the model. For an agent, this layer is primarily about two things: uptime (if one provider returns a 429 or a 500, the gateway retries the next one for free) and cost arbitrage (routing to whichever host currently offers the lowest price for a given open-weight model). We went deep on this category in LLM tool gateways: the 2026 builder's guide, and it has become close to mandatory infrastructure for any agent that needs to run reliably at scale.

The fee models are where the gateways differ, and the differences are small but real. OpenRouter is the default choice, routing across 60-plus hosts with automatic failover, normalized OpenAI-compatible tool calling, and price/throughput routing via its :floor (cheapest) and :nitro (fastest) suffixes. It takes no per-token markup, charging only a 5.5% fee when you top up credits (5% via crypto), and it exposes 25-plus free models for low-volume use - OpenRouter. Vercel AI Gateway goes further on price: zero markup, zero platform fee, and zero fee on bring-your-own-key requests, which makes it the cheapest pure passthrough on paper, with $5/month of free credits and a one-command setup for agent CLIs like Claude Code and Cursor - Vercel. Cloudflare AI Gateway makes its core features (caching, rate-limiting, retries, analytics) free and only charges a 5% fee on credits bought through its optional Unified Billing - Cloudflare.

The judgment for agent builders comes down to a single trade-off between total cost and reliability value:

• For a single-model, high-volume agent, going direct to the provider (or through Vercel's zero-fee gateway) beats paying OpenRouter's 5.5% top-up fee.
• For a multi-model or failover-critical agent, that 5.5% buys uptime and cost arbitrage that is worth far more than the fee.
• For caching-heavy agents, going direct to a host (DeepInfra, Fireworks, Groq) gives deterministic prompt caching that a marketplace cannot guarantee, because a routed request may land on a host without caching.

That last point is the subtle one and the reason routing is not a free lunch. When OpenRouter sends your request to whichever host is cheapest this second, you lose control over whether that host supports prompt caching, and for an agent whose economics depend on caching a fat system prompt, an inconsistent cache hit rate can cost more than the routing saves. The resolution most mature agent stacks reach is a hybrid: route through a gateway for failover and model diversity, but pin caching-critical, single-model workloads to a direct provider connection. The gateway is for resilience and arbitrage; the direct connection is for deterministic caching economics.

12. The seven levers that actually cut agent cost

Everything up to this point has been about choosing a model. This section is about the levers that move an agent's bill far more than the model choice does, and the reason it comes late is that they are what separate a naive $500 monthly bill from an optimized $50 one on identical work. We covered the full playbook in how to cut LLM costs: the 2026 efficiency guide, but the seven that matter most for agents specifically are worth walking through, because each attacks a different part of the cost structure. The single most important one, again, is prompt caching, because it directly attacks the re-sent-context problem that dominates agent cost. Caching a stable prefix lets every subsequent turn pay roughly 10% of the input rate for those tokens, which inverts old advice: a 50,000-token cached system prompt can cost less to run than a 5,000-token uncached one, as long as the static content sits first and dynamic content is injected last so cache hits do not collapse - DevToolLab.

The second lever, model routing and cascades, is where the 50x price spread from section 4 pays off. You run a cheap model first (a nano or cheap-tier worker) and escalate to a flagship only when confidence is low or the task is provably hard. Combined with caching, this took a code-review workload from $15-$25 per pull request down to $0.50-$1.50 at comparable depth - MorphLLM. Menlo Ventures notes that almost nobody routes multi-agent traffic yet, which means most teams are leaving this saving entirely on the table. We built the full case for it in AI model routing in 2026: cut agent costs 60%, and it is the highest-leverage architectural change most agent teams can make.

The remaining five levers each target a specific waste:

• Batch processing gives a flat 50% discount for non-interactive work (evals, enrichment, offline research), and stacks with cache reads toward roughly 95% savings on the repeated portion.
• Context compaction prunes stale tool outputs and old turns, directly shrinking the transcript that gets re-billed on every step.
• The effort dial turns reasoning-token spend down for easy steps and up only for hard ones, since thinking tokens bill at the output rate.
• Structured outputs constrain the model to a schema, eliminating a whole class of parse-failure retries that each re-send the full context.
• Off-peak scheduling on providers like DeepSeek halves the rate for work that can wait for the discount window.

The reason these levers compound rather than merely add is that they attack different terms in the same cost equation. Caching cuts the price of the re-sent prefix, compaction cuts the size of what gets re-sent, routing cuts the price of the model doing the sending, batch cuts the price of the whole job, and structured outputs cut the number of times you have to send it at all. Stack four of them and a workload that looked uneconomic at flagship prices becomes trivially cheap, which is exactly why the sticker price on a pricing page tells you so little about what an agent will actually cost. The teams that win on agent economics are not the ones who found the cheapest model. They are the ones who pulled every lever.

13. Real per-task cost math

Abstract per-token prices become intuitive only when you translate them into the cost of a completed task, so here are worked examples grounded in real published figures. The most concrete public benchmark is Claude Code, whose median cost runs about $6 per developer per day, with 90% of users staying under $12 per day - Anthropic. At the heavy end, an engineer pushing an agent through automation-heavy tasks with 400,000 to 2,000,000 cumulative input tokens per task can reach $500 to $2,000 per month. That thousand-fold range between a light and a heavy user, on the same tool, is entirely a function of how much context the agent drags around and how often it loops, which is the practical proof of everything in section 1.

The routing example is even sharper. A code-review agent that spins up parallel specialized sub-agents on a frontier model averages $15 to $25 per pull request. The same review depth, achieved with prompt caching and a cheap-model-first cascade, drops to $0.50 to $1.50 per pull request - MorphLLM. That is a 20-to-30x cost reduction on identical output, and it comes entirely from architecture, not from a cheaper model. The frontier model still does the hard part; it just does not do the easy 80% of the work that a cheap model could have handled. This is the single most important number in the guide for anyone trying to make agent economics work, and we expanded on why so many teams fail to capture it in AI agent ROI in 2026: why most pilots never scale.

The reason agent bills surprise people is captured in one measurement from Anthropic's engineering team: agents use about 4x the tokens of a chat interaction, and multi-agent systems about 15x, and token usage explained roughly 80% of the performance variance in their tests - Anthropic Engineering. That last clause is the uncomfortable part: spending more tokens is literally what buys the better result, so cost and quality are tightly coupled, and you cannot simply cut tokens without cutting quality. The escape is not to spend fewer tokens indiscriminately, it is to spend them on the right model at the right price, which is the entire argument for routing and caching over blanket downgrades.

The multi-agent multiplier deserves a note of caution for cost-conscious builders. A 15x token burn means orchestrator-worker patterns are only economically rational for high-value, heavily parallelizable tasks whose information genuinely exceeds a single context window. Spinning up five sub-agents to do work one agent could handle sequentially is a common and expensive mistake, because every handoff repeats context transfer and adds verification layers. We laid out when the pattern pays and when it does not in multi-agent orchestration: an agentic approach to LLMs, and the short version is that multi-agent is a scaling tool for genuinely parallel problems, not a default architecture.

14. How AI agents are reshaping the pricing field

The rise of agents is not just consuming the cheap tokens, it is changing what the providers build and how they price. Three shifts are visible in the 2026 pricing landscape, and each one is a direct response to agent workloads. The first is that caching moved from a nice-to-have to a headline feature, because agents are the workload that resends the same prefix thousands of times. Providers now compete on cache-read rates ($0.02 to $0.05 at the cheap end) as aggressively as they compete on base input rates, and some (DeepSeek, OpenAI) made caching automatic precisely so agent developers would not have to opt in. When a feature becomes automatic, it is because the dominant workload demands it, and that workload is agents.

The second shift is tiered and off-peak pricing, which exists because agent traffic is spiky and often deferrable. DeepSeek's off-peak windows, the Batch APIs across all major providers, and the long-context surcharges are all attempts to price the specific shape of agent demand: huge, bursty, context-heavy, and frequently non-interactive. This is a market maturing from "one price per token" toward "price the workload," and it rewards builders who understand their own traffic pattern. An agent team that knows which of its work is interactive (pay full price for low latency) and which is batchable (take the 50% discount) captures savings that a team treating all tokens identically leaves behind. We wrote the pricing-strategy side of this in price your AI product to beat token costs, and the same logic applies to buying tokens as to selling access to them.

The third shift is the most consequential and the one that changes the answer to "which API is cheapest": the emergence of the managed agent platform, which abstracts the token layer away entirely. Instead of choosing a model, wiring up caching, and building routing logic, you describe what you want an agent to do and the platform handles the model selection, the cost optimization, and the orchestration underneath. Anthropic's own Managed Agents surface runs the agent loop and hosts the tool sandbox so you never touch the token math, and platforms like o-mega take the abstraction further still, letting you build and run an entire autonomous company through conversation while the model routing and cost control happen out of sight. This is worth mentioning because it reframes the cheapest-API question for a large class of builders: for a team whose goal is outcomes rather than infrastructure, the cheapest path may be not choosing a model at all and letting a managed layer optimize the tokens on their behalf. This is not the right answer for everyone (teams that need deterministic control over caching and routing will still go direct), but it is a genuine third option alongside "direct provider" and "gateway," and it is growing fast because the token-optimization work this guide describes is exactly the kind of undifferentiated heavy lifting that most teams would rather not own.

Yuma Heymans, who founded o-mega and co-founded the AI recruitment platform HeroHunt.ai, has argued that the economics of an agent workforce live or die on this exact tension: an agent fleet's dominant running cost is token spend, so the choice between a cheap-but-capable API and smart routing is what makes deploying many agents at once financially viable in the first place. You can follow his writing on the agent-workforce economy at @yumahey.

15. Where cheap wins and where it fails

Honesty about the limits of "cheapest" is what separates a useful guide from a race to the bottom, so this section is deliberately balanced. Cheap wins decisively in a specific and large set of cases: high-volume, well-defined, repetitive steps where the task is bounded and the model does not need to reason its way out of ambiguity. Classification, extraction, routing, formatting, first-pass triage, and any step where a cheap model's output feeds into a verification layer are exactly where the nano and cheap tiers shine. In these cases, paying frontier prices is pure waste, and the routing discipline of "cheap first, escalate rarely" captures nearly all the savings with almost none of the quality loss. If your agent's work decomposes cleanly into many simple steps, the cheap tiers will run it for a tenth of what a naive single-flagship design costs.

Cheap fails, and fails expensively, in the opposite regime: long-horizon, open-ended, high-stakes tasks where a single wrong turn compounds. A coding agent doing a multi-file refactor, a research agent running a fifteen-step investigation, or any workflow where step ten depends on step three being correct is where a cheap model's slightly-lower reliability turns into a cascade of wasted downstream work. Here the frontier models earn their premium not by being smarter per token but by being right more often on the first attempt, which means fewer retries, fewer dead-end branches, and fewer times the whole loop has to restart. The false economy of running Opus-class work on a nano model is real, and it shows up as a bill that is higher, not lower, because the cheap model looped ten times where the expensive one would have finished once.

The synthesis, and the thing that makes this a genuinely hard engineering problem rather than a simple "pick the cheapest" exercise, is that the same agent contains both regimes. A single agent task typically has a few genuinely hard steps embedded in many easy ones, which is precisely why routing beats both "always cheap" and "always expensive." The teams that get agent economics right do not pick a tier, they build a system that puts each step on the right tier, and they measure the completed-task cost rather than the per-token price. That measurement discipline is the whole game: as we documented in the cost of AI agents: uncovering the true cost of agentic AI, the teams that fail are almost always the ones who optimized the sticker price and never measured what a task actually cost to complete.

16. The future outlook for agent economics

Three trends will define agent costs over the next year, and they push in different directions. The first is that LLMflation continues, so the per-token price of any given quality tier will keep falling roughly 10x per year - a16z. Taken alone, this means every agent workload gets cheaper by default, and workloads that are marginal today become trivially affordable within a year. This is the tailwind, and it is the reason the smart move is often to build for the capability you need now and let the price come down to meet you, rather than compromising on a weaker model to save money that time will save for you anyway.

The second trend runs against the first: agent architectures keep getting more token-hungry. Multi-agent systems, longer reasoning chains, larger context windows, and more aggressive tool use all consume the savings that LLMflation provides. Google's sevenfold year-over-year token growth is the macro signature of this, and it means aggregate spend keeps rising even as unit prices fall - Menlo Ventures. The net effect for any given team depends entirely on which force dominates their workload, and the lever that decides it is architectural discipline: the teams that pull the caching, routing, and compaction levers ride the price decline, while the teams that let their agents sprawl watch consumption outrun the savings.

The third and most interesting trend is the shift of optimization up the stack. As caching, routing, and batching become table stakes, the differentiation moves from "which model is cheapest" to "which system optimizes tokens best," and that is increasingly a job for the platform rather than the individual builder. Automatic caching, server-managed context compaction, and managed routing are all examples of the provider absorbing work that builders used to do by hand. The endpoint of this trend is that for a large class of applications, the token-optimization problem this entire guide describes becomes invisible, handled by a managed layer, in the same way that most developers no longer hand-tune database query plans. The cheapest LLM API of 2027 may not be a model at all, it may be a system that picks the model for you, and the builders who win will be the ones who understood the economics well enough to know when to hand them off. We track this convergence in our ongoing coverage of the best LLM for AI agents, and the ranking shifts month to month precisely because the field is moving this fast.

17. Conclusion: a decision framework

The cheapest LLM API for your agent is not a model on a price list, it is a system that puts each step on the right tier and squeezes the architecture. If you take one thing from this guide, take the reframe: stop comparing per-token prices and start measuring per-completed-task cost, because the two diverge by an order of magnitude the moment you introduce a tool-calling loop. A model that is twice the price per token can be a fraction of the cost per task if it caches your prefix, calls tools reliably, and finishes in fewer steps, and a nano model that fails and loops can cost more than a frontier model that gets it right once.

For a concrete starting point, here is the framework the evidence supports. Route the easy, high-volume 80% of your agent's steps to the cheap and nano tiers, where GPT-5.6 Luna, Gemini 3.1 Flash-Lite, Grok 4.1 Fast, and Qwen3.5-Flash all deliver reliable tool calling for well under a dollar per million blended tokens. Reserve the hard 20% for a cheap-frontier model like Grok 4.6 at $2/$6, or a true frontier model like Claude Opus 5 when correctness on a long autonomous task genuinely outweighs cost. Turn on prompt caching for anything that resends a static prefix, take the 50% Batch discount for anything non-interactive, and put a gateway in front for failover while pinning caching-critical workloads to a direct connection. Pull those levers and a workload that looks like $500 a month at flagship prices runs closer to $50.

And if the token-optimization work itself is not where you want to spend your engineering time, the honest answer is that managed platforms like o-mega now do this heavy lifting for you, choosing and routing models underneath an outcome-level interface, which for many teams is the genuinely cheapest path because it removes the optimization problem rather than solving it by hand. Whichever route you take, the discipline is the same: the field moves monthly, the prices in this guide are snapshots, and the only durable advantage is understanding the mechanics well enough to re-optimize as the market shifts underneath you.

This guide reflects the LLM API pricing landscape as of late August 2026. Model prices, promotional windows, and available tiers change constantly in this market: two promotional rates cited here (Claude Sonnet 5's introductory pricing and GPT-5.6 Sol's promo) expire in September and November 2026 respectively, and new models launch monthly. Verify current pricing on each provider's official page before committing a production workload.