A8gent
A8gent
Comparison

Cheapest LLM API for AI Agents (2026)

Real price-per-workload comparison of every major LLM API for agent work, with August 2026 prices, caching maths and the honest cheapest pick.

Cheapest LLM API for AI Agents (2026) visual
AI Agent Starter Kit cover

Free download

AI Agent Starter Kit

Workflow picker, ROI worksheet, 40-prompt pack, and the first-agent rollout playbook. The 1-hour version of the entire A8gent system.

Workflow picker
ROI worksheet
Prompt checklist
Team rollout plan
Open it now

No spam. Worksheet + prompt checklist + rollout plan delivered instantly.

Contents
  1. Fast answer
  2. Quick facts
  3. What this covers
  4. Why it matters
  5. Where to go next
  6. Outcomes
  7. Step by step
  8. Cost per workload, which is the only number that matters
  9. Where cheap models genuinely fall down
  10. The costs that do not appear on the pricing page
  11. At a glance
  12. Mistakes to avoid
  13. FAQ
  14. Related guides
TL;DRAnswer-first

Fast answer

On list price alone, the cheapest capable APIs for agent work as of August 2026 are Z.ai's GLM-4.7-FlashX at $0.07 per 1M input and $0.40 output, DeepSeek V4-Flash at $0.14 and $0.28 with cache hits near $0.003, and 8B-class Llama models at about $0.05 and $0.08 on fast hosts. Among providers with US or EU corporate terms, Google's older Gemini Flash-Lite tiers at $0.10 and $0.40 are the cheapest, with OpenAI's budget tier at $0.20 and $1.20 close behind. But price per token is the wrong unit. What determines your bill is tokens per workload, and the two levers that dominate it are prompt caching, which cuts repeated-prefix input cost by ten to fifty times depending on provider, and model routing, which keeps expensive models off the routine steps. A well-built two-model automation on mainstream US providers routinely costs less than a badly built one on the cheapest model on the market. Optimise the workload first, then the price.

Facts last verified 2026-08

Quick facts

Cheapest paid tier found
Z.ai GLM-4.7-FlashX, $0.07 in / $0.40 out per 1M (Aug 2026)
Cheapest with US or EU terms
Gemini 2.5 Flash-Lite, $0.10 in / $0.40 out per 1M
Deepest cache discount
DeepSeek, cache hits about 2 percent of the miss price
Deepest batch discount
Moonshot at 60 percent on the K2.x line; Anthropic and Google about 50 percent
Typical monthly spend
Single-digit to low-double-digit dollars for one small business automation
Biggest lever on your bill
Prompt caching and per-step model routing, not provider choice

On this page

What this page covers

A comparison visitor should understand the tradeoff, the best-fit scenario, and the next diagnostic tool to confirm the choice.

  1. 01Price table
  2. 02Cost per workload
  3. 03Caching
  4. 04Reliability trade-off
  5. 05Verdict

Why does this matter now?

The cheapest-hire framing only holds if the wage is genuinely small, and for most small business automations it is: single-digit dollars a month, not hundreds. The risk is not overspending on tokens, it is picking a model on headline price, discovering it fails on your real cases, and concluding that automation does not work. Cost and reliability are one decision, not two. Getting it right means you can afford to automate the workflows that were previously not worth the effort, which is where most of the value in small business automation actually sits.

Internal path

Where to go next from this page

These links are part of the A8gent learning and conversion path. Use them to move from concept, to diagnosis, to workflow build, to course.

Start with readiness

What you should be able to do after this

  • Compare real cost per workload, not per token
  • Understand caching and batch discounts
  • Pick a cheap model without breaking reliability
  • Model your own monthly bill

How do you do it, step by step?

1. Measure tokens per run before you compare prices

Take one real example of the workflow and count the input and output tokens it actually consumes, including the system prompt, tool definitions and any documents. Most people are surprised: the system prompt and tool schemas are frequently larger than the actual task content. Until you have that number, every price comparison is theoretical.

2. Multiply by realistic monthly volume, then triple it

Take your token count per run, multiply by expected runs per month, and multiply by the provider's input and output rates. Then triple the result to allow for retries, long edge cases and growth. If the tripled figure is still comfortable, price is not your deciding factor and you should choose on reliability instead.

3. Work out how much of your input is cacheable

Anything that repeats between runs - system prompt, tool schemas, few-shot examples, reference documents - can bill at a fraction of the normal input rate. Discounts range from roughly ten times on the US majors to roughly fifty times on DeepSeek. On a typical agent this is the single biggest lever on the bill, and it costs nothing but prompt structure.

4. Move everything that can wait to batch

Anthropic and Google publish batch discounts around 50 percent and Moonshot around 60 percent on part of its lineup. A large share of business automation is genuinely batch work built as real-time out of habit: overnight document processing, database enrichment, backlog summarisation. Rewriting one of those as a batch job halves its cost with no quality change.

5. Route by step, not by workflow

Run each step on the cheapest model that passes your evaluation for that specific step. In a well-built automation the flagship handles maybe one step in ten. Pipelines that run entirely on a flagship are usually overpaying by several times for work that a budget tier handles identically.

6. Build an evaluation set of twenty real cases

Collect twenty genuine examples from your business with known correct answers, then run every candidate model against them and grade the outputs. This takes an afternoon, costs pennies at budget-tier prices, and is worth more than every public benchmark combined because it measures your workflow rather than someone else's.

7. Check the data terms before you commit to a cheap provider

Cheap providers differ sharply on data handling. DeepSeek's policy states PRC processing and training on inputs by default; Moonshot's terms permit using content to improve the service; Z.ai states prompts are not stored; Alibaba pledges no training. None of that is disqualifying on its own, but it needs to be a deliberate decision rather than a discovery.

8. Set a hard spend cap and step limits

Every provider dashboard supports a spend limit. Set one. Then cap the maximum steps and the timeout on every agent loop so a stuck run fails and escalates rather than retrying forever. Runaway loops, not model prices, are how automation bills actually get alarming.

Cost per workload, which is the only number that matters

Per-token prices are a distraction until you attach them to a job. Take three workloads a small business would actually automate and price them at August 2026 rates. Workload one: email triage, 3,000 input and 400 output tokens per run, 1,000 runs a month. Workload two: document extraction, 4,000 input and 200 output tokens, 2,000 runs a month. Workload three: a ten-step research agent, roughly 40,000 accumulated input and 3,000 output tokens per run, 200 runs a month.

On a budget tier at around $0.15 input and $0.50 output per million, workload one costs about $0.65 a month, workload two about $1.40, and workload three about $1.50. On a flagship at $5 and $30, the same three come to roughly $27, $52 and $58. Every one of those numbers is small against the labour it replaces. The flagship figures are not scary, they are simply forty times larger than they need to be for work a budget model handles identically.

Now add caching. Workload one has a 2,000-token system prompt and tool schema that never changes, so two thirds of its input caches. On a US provider at a tenth the cached rate, the input cost drops by roughly 60 percent. On DeepSeek at around a fiftieth, it effectively disappears. The provider you pick moved the bill by a factor of forty; the caching you configured moved it by another factor of two to three, for free.

The lesson is the ordering. Measure your tokens, structure your prompts so the stable part caches, move batch-shaped work to batch pricing, route each step to the cheapest model that passes your evaluation, and only then argue about providers. Teams that do it in that order end up with bills in the single digits regardless of which vendor they chose.

Where cheap models genuinely fall down

It would be dishonest to present budget models as free flagship capability. They fail in characteristic ways and it is worth knowing which, so you can put the expensive model exactly where it earns its price.

The first failure mode is ambiguity. Given a clear rule and a clean input, a budget model applies it as well as anything. Given an input that does not match any rule, a flagship is more likely to notice and escalate while a budget model is more likely to force it into the nearest category. That is why every automation we build routes low-confidence cases to a human rather than trusting any model's judgement on the edge cases.

The second is long tool-calling chains. Errors compound: a slightly wrong argument on step three produces a confused step four, and by step eight the run is nonsense. Budget models tolerate fewer steps before this happens. The mitigations are structural rather than model-related - validate every tool call against your schema, cap the step count, checkpoint state so a failed run resumes rather than restarts - but a cheaper model needs them more.

The third is unedited customer-facing text. Tone, nuance and knowing what not to say are exactly where the money in a frontier model goes. If the output goes to a customer without a human reading it, use the better model. If a human reviews it, the budget model's draft is usually fine and the human is doing the quality control you would otherwise be paying for per token.

None of these argue against cheap models. They argue for putting them where they work, which is most places, and being deliberate about the small number of steps where they do not.

The costs that do not appear on the pricing page

Retries are the first. Any production automation retries on transient failures, and a provider with less consistent latency or tighter rate limits produces more retries, each of which bills again. A model that is 30 percent cheaper but retries twice as often is not cheaper. Watch the actual token spend for a week rather than the projected one.

Rate limits are the second. Several cheap providers start new accounts at a few requests per minute, which will throttle a batch job into taking all night or failing. That is not a cost in dollars but it is a cost in delivery time and it surprises people who benchmarked with a single request.

Migration is the third, and it is the largest. Fast-moving providers deprecate models on their own schedule, and a model swap means re-running your evaluation, re-tuning prompts that were fitted to the old model's quirks, and re-testing the whole workflow. Budget a day per migration and keep the model name in configuration so you are editing a value rather than hunting through code.

Compliance work is the fourth. If a provider's terms mean you need a transfer assessment, a client notification or an added subprocessor entry, that is real hours from someone whose time costs far more per hour than any model. For a low-volume automation, choosing the provider with terms you already have documented can be cheaper overall than the one with the lowest tokens.

Put all of that together and the practical conclusion is the one we keep landing on: the difference between a well-built automation and a badly built one dwarfs the difference between providers. If you want the build done properly, with the model routing, caching, guardrails and handover documentation in place, the free automation audit is where that starts and the automation services page sets out what a full engagement includes.

At a glance

Cheapest listed model per provider, list prices per 1M tokens as of August 2026

ProviderCheapest listed modelInputOutputBased in
Z.aiGLM-4.7-FlashX$0.07$0.40China, Singapore endpoint
Meta Llama (Groq)Llama 3.1 8B Instant$0.05$0.08Host-dependent
Google Gemini2.5 Flash-Lite$0.10$0.40United States
MistralSmall 4$0.10$0.30France
DeepSeekV4-Flash$0.14$0.28China
OpenAIGPT-5.6 budget tier$0.20$1.20United States
Alibaba Qwenqwen3.6-flash$0.25$1.50China, Singapore endpoint
Moonshotkimi-k2.5$0.60$3.00China, Singapore endpoint
AnthropicClaude Haiku 4.5$1.00$5.00United States
xAIgrok-build-0.1$1.00$2.00United States

What mistakes should you avoid?

  • Comparing headline per-token prices without measuring tokens per run first
  • Ignoring prompt caching, which is usually a larger saving than switching providers
  • Running an entire pipeline on a flagship model when one step in ten needs it
  • Building batch-shaped work as real-time and paying double for no benefit
  • Choosing a provider on price without reading its data-handling terms
  • Switching models without an evaluation set of real cases to check nothing broke
  • Leaving agent loops without step limits, timeouts or a hard spend cap

FAQ

What is the cheapest LLM API in 2026?
On list price as of August 2026, Z.ai's GLM-4.7-FlashX at $0.07 per 1M input and $0.40 output is the cheapest paid tier we found, with a free Flash tier below it. DeepSeek V4-Flash at $0.14 and $0.28 goes lower still on cache hits, around $0.003 per 1M. Among providers with US or EU corporate terms, older Gemini Flash-Lite tiers at $0.10 and $0.40 are the cheapest.
Is the cheapest model good enough for business automation?
For classification, extraction, tagging, routing and first-draft writing, budget models are generally fine and the gap to flagships is small. Where they fall short is ambiguous multi-step reasoning, long tool-calling chains and anything a customer reads unedited. The standard answer is a two-model stack, with a cheap model on the volume and a strong model on the judgement steps.
How much should a small business expect to spend on model tokens?
For a single well-scoped automation, typically a few dollars to a few tens of dollars a month. A thousand email triage runs on a budget tier is around a dollar; on a flagship it is closer to thirty. Model spend is almost never the largest line in an automation budget, which is why reliability usually deserves more weight than price.
Does prompt caching really save that much?
Yes, and it is usually a bigger saving than switching provider. Agent loops resend the same system prompt and tool schemas every turn, and cached input bills at roughly a tenth of normal on the US majors and around a fiftieth on DeepSeek. On a busy agent, structuring prompts so the stable part caches routinely halves the bill with no change to output quality.
Are Chinese model APIs safe for business use?
It depends on the provider and the data, and the answer is not uniform. Z.ai publishes a no-storage claim and runs from Singapore, and Alibaba pledges never to train on your data. DeepSeek's policy states PRC processing and training on inputs by default, and Moonshot's terms permit using content to improve the service. Read the specific terms, weigh them against the data you would send, and note that several publish open weights you can self-host instead.
Is OpenRouter cheaper than going direct?
Sometimes. OpenRouter passes through provider rates without an inference markup, taking a fee on credit purchases instead, and third-party hosts occasionally list a model below its first-party price. Its more useful features for cost work are cross-provider testing without separate integrations and filtering by data policy. Its free tiers are rate-limited and not suitable for production.
Should I self-host to save money?
Rarely on cost grounds alone. A GPU server plus the engineering time to keep it patched, monitored and available will usually exceed a few hundred dollars a month of API spend, and API spend is someone else's uptime problem. Self-host when the data legally cannot leave your network, which is a much better reason and one that no API contract solves.
How do I stop an automation running up a surprise bill?
Three controls, all of which take minutes. Set a hard monthly spend limit in the provider dashboard. Cap the maximum steps and the timeout on every agent loop so a stuck run escalates to a human instead of retrying forever. And default routine steps to a cheap model, escalating only where your evaluation shows it is needed.

Sources & further reading

Done for you

Want this built for your business?

Tell us the workflow. We scope, build, and ship the agent with guardrails and the numbers to prove it worked. The scoping call is free.

Free scoping call. You own the code.

Request a scoping call

Was this page helpful?