Contents
- Why the Running Bill Surprises People
- Meter 1: Tokens, and the Input/Output Asymmetry
- The One Lever That Changes the Token Arithmetic
- Meter 2: Task vs Credit vs Execution vs CPU Second
- Meters 3 and 4: The Lines Nobody Quotes
- Meter 5: The Human Hours That Never Go Away
- Worked Monthly Bill A: Internal Document Triage (Illustrative)
- Worked Monthly Bill B: Inbound Voice and SMS Booking (Illustrative)
- Which Question Each Page Answers
- FAQ
Why the Running Bill Surprises People
Almost every conversation about the cost of automation is a conversation about the build. That question has a clean answer, and we answer it on the AI automation cost page for hiring and agency pricing, and on the automation build cost page for what a single scoped workflow costs to construct. This page answers the question that catches people out: once it is built and switched on, what shows up on the card every month?
The surprise is structural. A build price is one number from one supplier. A running bill is five meters from five suppliers, and no two measure the same thing:
- Model tokens - metered per million, with input and output priced differently.
- The automation platform - metered per task, per credit, per execution or per CPU second depending on which one you picked.
- Telephony and messaging - metered per minute and per SMS segment, plus per-number rental.
- Storage and observability - vector databases metered per gigabyte and per read/write unit, tracing metered per event.
- Human review - metered in hours, and the only line that does not appear on any invoice.
Each meter is individually cheap. It is the interaction between them that produces a number nobody forecast. A workflow that runs 10,000 times a month is a rounding error on one meter and a four-figure line on another, purely because of how that platform counts.
A note on dates. Every price below was read from the vendor's own public pricing page in August 2026. None of these vendors stamp their pages with a version date, so treat every figure as "what the page said when we looked" and re-check before you commit budget. Where a figure is not published, we say so instead of estimating it.
Meter 1: Tokens, and the Input/Output Asymmetry
A token is roughly three-quarters of a word. You pay for tokens going in and tokens coming out, at different rates. From OpenAI's published pricing page as of August 2026:
| Model | Input / 1M | Cached input / 1M | Output / 1M |
|---|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 | $30.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
| gpt-4o-mini | $0.15 | $0.075 | $0.60 |
Source: OpenAI's API pricing documentation, read August 2026, which also notes 50% batch reductions on most models.
For Anthropic's Claude models we could not load Anthropic's own pricing page during this research - the request failed a TLS certificate check on every attempt - so we will not reproduce that table from memory. What we can cite is OpenRouter's published model pages: Claude Opus 5 at $5 per million input and $25 output, Claude Haiku 4.5 at $1 input and $5 output. Read the number off the provider's own console before you commit budget.
Three things follow, and they are the whole reason a chatty agentic workflow costs what it does.
Output is 5-6x the price of input, but you send far more input. An agent loop re-sends the entire conversation on every step: the system prompt, every tool definition, every prior message, every tool result. A six-step loop might push 40,000 input tokens to produce 1,300 output tokens - at gpt-5.6-terra rates, $0.080 of input against $0.016 of output. The expensive-looking column is not the one doing the damage.
A long system prompt is a fixed tax on every step. If your instructions and tool schemas come to 3,000 tokens, a six-step loop pays for them six times - 18,000 tokens before a word of actual work. At 10,000 conversations a month that one prompt is 180 million input tokens, or $360 at gpt-5.6-terra rates, for text that never changes.
Retries multiply everything. A malformed JSON response, a timed-out tool, a rate limit that triggers a backoff: each retry re-sends the full accumulated context, and the retried steps tend to be the late ones carrying the largest context. Retry rate is a cost metric, not just a reliability metric, and it belongs on the same dashboard as spend.
The One Lever That Changes the Token Arithmetic
Because so much of each agent request is the same bytes as the last one, providers let you cache the repeated prefix. OpenRouter's prompt caching documentation, read August 2026, states that for Anthropic models cache writes are charged at 1.25x the base price and cache reads at 0.1x. For OpenAI it notes writes at 1.25x on GPT-5.6 and later (no write cost before that) and reads at either 0.25x or 0.50x depending on model - OpenAI's own table shows the read rate directly in the "cached input" column above.
That 0.1x is the difference between a viable unit economic and an unviable one. Apply it to the system-prompt example: 180 million tokens of repeated prefix at full input price is $360 a month; at a tenth of the rate it is $36, plus the writes.
Caching is a prefix match, which is the part that trips people up. Any byte that changes invalidates everything after it. Put a timestamp, a session ID or a customer name at the top of your system prompt and you have silently turned caching off - no error, no warning, just a bill that never comes down. The fix is ordering: frozen content first, volatile content last. The mechanics are in the prompt caching guide, and the broader set of levers in reduce AI agent LLM costs.
The budgeting implication: do not forecast the token line from an unoptimised prototype. A prototype that has never been cached, trimmed or routed is an upper bound, not a forecast. Equally, the savings do not arrive by themselves - they arrive when somebody deliberately orders the prompt and verifies cache hits in the usage response.
Meter 2: Task vs Credit vs Execution vs CPU Second
This is the line that swings hardest, and it swings for a reason that has nothing to do with how much work your automation does. The four major platforms meter four genuinely different units. We have a glossary entry on execution vs task vs operation because the distinction confuses almost everyone the first time.
From each vendor's own pricing page, read August 2026:
| Platform | Billing unit | Published entry pricing |
|---|---|---|
| Zapier | Task = one successful action step | Free 100 tasks/mo. Professional $29.99/mo (or $19.99 annual) for 750 tasks; $73.50 / $49.00 for 2,000; $733.50 / $489.00 for 100,000. |
| Make | Credit = one module action | Free 1,000 credits/mo. Core $9/mo for 10,000 credits; Pro $16/mo; Teams $29/mo. Annual stated to save 15%+. |
| n8n | Execution = one full workflow run | Cloud Starter €20/mo for 2,500 executions; Pro €50/mo for 10,000; Business €667/mo for 40,000. Community Edition self-hosted and free. |
| Latenode | CPU second of actual run time | 10,000 CPU seconds free/mo, then $0.00012/sec (10,001-100,000), $0.00011/sec (100,001-200,000), down to $0.00005/sec above 5M. |
Now put one workflow through all four meters: an eight-step workflow running 10,000 times a month, a common shape for lead routing or ticket triage.
- Per action step: up to 80,000 billable units - though Zapier's page is explicit that triggers and polling do not count, that its own built-in data tools (Formatter, Paths, Filter) do not count, and that failed actions consume no task, while some actions cost multiple tasks. The real count depends on how many of your steps are integrations rather than built-ins.
- Per module credit: most actions consume one credit, with routers and error handlers explicitly free - a similar order of magnitude, on a plan whose entry tier includes 10,000 credits for $9.
- Per execution: 10,000 units flat. The eight steps are irrelevant. Add two more and the bill does not move.
- Per CPU second: 10,000 runs times the average seconds each run takes. A 2-second run is 20,000 CPU seconds; a run waiting 30 seconds on a slow API is 300,000. Step count is irrelevant; duration is everything.
The same automation is priced on step count, module count, run count and elapsed time. That is why "which platform is cheapest" has no general answer, and why the honest version of the question is "which meter does my workflow shape look cheap on?":
- Many steps, few runs - per-execution or per-CPU-second metering flatters you; per-task punishes you.
- Few steps, huge run volume - per-execution metering bites, because every run costs the same whether it did anything or not. Filtering early, before the run counts, is the lever.
- Runs that wait on slow external systems - CPU-second metering is the one to watch; Latenode's page is explicit that the formula is monthly runs multiplied by average seconds per run.
We compare these platforms head to head in n8n vs Make vs AI agents, and the cheapest AI automation tools roundup covers the low end. The point here is narrower: count your workflow in all four units before you pick.
Meters 3 and 4: The Lines Nobody Quotes
These turn a tidy forecast into a surprise. None are large individually. All are recurring.
Telephony
If the agent answers or places calls, you are buying minutes. From Twilio's US voice pricing page:
- Outbound to local or toll-free numbers: $0.0140 per minute
- Outbound over browser, app or SIP: $0.0040 per minute
- Inbound to a local number: $0.0085 per minute, plus $1.15 per month for the number
- Inbound to a toll-free number: $0.0220 per minute, plus $2.15 per month for the number
That is the carriage only. Speech-to-text, text-to-speech and the per-minute platform fee charged by a voice agent vendor sit on top, and those vary enough by vendor and voice model that we will not put a single number on them - check the specific vendor's page, and see Vapi vs Retell vs Bland for how the three compare. The structural point stands: a voice agent has a per-minute floor that a text agent does not, and 4,000 minutes a month of inbound local carriage alone is $34 before anything intelligent happens.
SMS segments
Twilio's US SMS page lists $0.0083 per message outbound and inbound, and states that text messages are charged per segment. That word is the trap: a long message is several segments and therefore several charges. On top, the page lists carrier surcharges applied automatically by destination carrier - AT&T long code +$0.0035, T-Mobile +$0.0045, Verizon +$0.0045 outbound - and a $0.001 processing fee per failed message. Budget on segments and carrier fees, not the headline rate. Registration under A2P 10DLC is a separate prerequisite, covered in the A2P 10DLC guide.
Vector storage
If the agent retrieves from your documents there is a vector database underneath it. Pinecone's pricing page lists Builder at $20/month, Standard at a $50/month minimum and Enterprise at a $500/month minimum, with database costs broken out as storage at $0.33/GB, read units at $16-$27 per million and write units at $4-$6.75 per million. The plan fee is predictable; the read units scale with how chatty the agent is, because every retrieval is reads.
Observability
You cannot run an agent you cannot see, which makes observability a running cost rather than an optional extra. Langfuse's pricing page lists a free Hobby tier at 50k units/month, Core at $29/month for 100k units with $8 per additional 100k, Pro at $199/month and Enterprise at $2,499/month, where a unit is any tracing data point - a trace, an observation or an evaluation score. Self-hosting the open-source version is free apart from the server. Note the unit definition: one conversation is many units, so tracing volume scales with the agent's own chattiness.
Meter 5: The Human Hours That Never Go Away
This is the line most forecasts omit entirely, and it is frequently the largest one at small volumes.
Any agent worth deploying has a human in the loop somewhere: approving outbound messages, checking the exception queue, reviewing the weekly log for what went quietly wrong. That time does not trend to zero as the system matures - it changes shape. Early on it is "check everything"; later, "check what was flagged plus a sample"; later still, "read the weekly report and act on the two anomalies". Less time, never no time.
We will not publish a benchmark for how many hours this takes, because we do not have one and neither does anyone quoting you a percentage. What we would say is: estimate it in hours per week, price it at a fully loaded hourly rate, and put it on the same page as the software. If the automation saves 10 hours a week and costs 2 to supervise, the honest number is 8, written down as 8 from the start. A forecast that quietly assumes zero supervision is why projects that look cheap on paper feel expensive in practice.
Two related costs sit in the same bucket. Change maintenance: an upstream API changes, a field gets renamed, a vendor deprecates a model, somebody fixes it. Drift review: outputs fine at launch want re-checking two quarters later against cases you did not have at launch. Neither has a published rate. Both are hours.
Worked Monthly Bill A: Internal Document Triage (Illustrative)
This is an illustrative model, not a client case study or a measurement. A8gent is a small practice founded in 2026 with no client billing data to publish. What follows is arithmetic on the published rates above, shown so you can substitute your own volumes. Every rate is cited; every volume assumption is ours and labelled.
The shape: an internal agent that reads inbound supplier documents, extracts a handful of fields, checks them against a system of record, and either files them or routes an exception to a person. Assume 6,000 documents a month, roughly 9,000 input and 600 output tokens each once the loop is accounted for, and an eight-step workflow on a per-execution platform.
| Line | Basis | Monthly |
|---|---|---|
| Model input, uncached | 6,000 x 9,000 = 54M tokens @ $2.00/M (gpt-5.6-terra list) | $108.00 |
| Model input, prefix cached | Assume 70% cached: 37.8M @ $0.20/M + 16.2M @ $2.00/M | $39.96 |
| Model output | 6,000 x 600 = 3.6M tokens @ $12.00/M | $43.20 |
| Automation platform | 6,000 executions - n8n Cloud Pro (10,000 included) | €50.00 |
| Vector storage | Pinecone Standard, published $50/mo minimum | $50.00 |
| Tracing | ~14 units per document x 6,000 = 84k - Langfuse Core (100k included) | $29.00 |
| Human review | Assumed 3 hrs/week at an assumed $40/hr loaded rate | $520.00 |
| Total (with caching) | ~$682 + €50 |
Two observations. First, the software is not the expensive part: at this volume the entire technical stack is around $160 a month and the human line is more than three times that. Second, caching moved the token bill by $68 - roughly 40% of technical spend - for an afternoon of prompt reordering.
Change one assumption and watch it move. No caching: add $68. Review at 8 hours a week instead of 3: add $866. Triple the documents to 18,000 and the model lines triple, the n8n plan jumps a tier, tracing goes into overage at $8 per additional 100k units - and the human line probably does not triple, which is the entire economic argument for automating in the first place.
Worked Monthly Bill B: Inbound Voice and SMS Booking (Illustrative)
Again: illustrative arithmetic on published rates, not a measured result.
The shape: an agent that answers the phone when nobody picks up, takes booking details, confirms by text and writes to the calendar. Assume 1,200 inbound calls a month averaging 3 minutes, 2 local numbers, one confirmation text and one reminder text per booking, 800 bookings, and each text running to 2 segments.
| Line | Basis | Monthly |
|---|---|---|
| Inbound voice carriage | 3,600 min @ $0.0085/min (Twilio US local inbound) | $30.60 |
| Phone numbers | 2 local numbers @ $1.15/mo | $2.30 |
| Outbound SMS | 1,600 messages x 2 segments = 3,200 segments @ $0.0083 | $26.56 |
| SMS carrier surcharges | 3,200 segments @ assumed $0.0045 blended (published $0.0035-$0.0045) | $14.40 |
| Voice platform (STT, TTS, per-minute fee) | Not published as a single comparable rate - varies by vendor, voice and model. Get it quoted. | see note |
| Model tokens | Assume 20k in / 2k out per call: 24M @ $2.00/M, 2.4M @ $12.00/M | $76.80 |
| Automation platform | ~2,000 executions - n8n Cloud Starter (2,500) | €20.00 |
| Tracing | Under 100k units - Langfuse Core | $29.00 |
| Human review | Assumed 4 hrs/week at an assumed $40/hr loaded rate | $693.00 |
| Total excluding the voice platform fee | ~$873 + €20 |
The row that matters most is the one we left blank. The voice platform fee is the largest technical variable in a voice build and the one without a single published number. Anyone quoting a total monthly cost for a voice agent without pinning it down is guessing. Ask for it in dollars per minute, all-in, including speech recognition and synthesis, then multiply by your expected minutes - not a demo's minutes.
Note how the per-minute and per-segment lines behave: they scale linearly with success. A voice agent that works better handles more calls and costs more to run. That is the good kind of cost, but it means a fixed monthly budget will eventually be breached by a win.
Which Question Each Page Answers
Three cost questions get tangled together constantly. They have different answers and live on different pages:
- "What does it cost to have this built or to hire someone?" - that is /ai-automation-cost. Agency retainers, consultant day rates, DIY tooling, what different engagement shapes actually cost.
- "What does one specific workflow cost to construct?" - that is /automation-build-cost. Scope, complexity drivers, and what moves a build from the low end to the high end.
- "What does it cost to keep running after handover?" - this page. Five meters, every month, forever.
Get all three on one sheet before deciding anything. A build that is cheap to make and expensive to run is a worse deal than the reverse, because the second number recurs. The total cost of ownership is build plus twelve months of running plus the review hours - and that is the number to compare against doing the work by hand.
How to build your own forecast in an hour
- Count your runs. Not the theoretical maximum - the realistic monthly count, including runs that end in "nothing to do".
- Count your steps and your seconds, then price the same workflow on all four platform meters and pick the one your shape is cheap on.
- Measure tokens on a real run, not a demo. Log input and output tokens per conversation, multiply by monthly runs, then check the usage response to confirm the repeated prefix is genuinely being cached.
- Add every per-unit external meter: minutes, segments, numbers, vector reads, tracing units.
- Write down the human hours and price them. If you cannot estimate, run the workflow manually for a week and count.
- Add headroom for retries, tier jumps and the volume growth success causes. We have no measured figure to offer here, but every one of the five meters has a discontinuity in it, and forecasts that assume smooth scaling meet a plan boundary eventually.
If you would rather someone else did that arithmetic against your actual process, that is what the free automation audit produces. Our automation services page explains what a build-and-hand-over engagement includes - documentation plus a recurring plain-language report, so you can see what ran and what it cost without reading five dashboards.
FAQ
- How much does it cost to run an AI agent per month?
- There is no single answer, because the bill is five separate meters and the mix depends entirely on the workload. What we can say from the published rates is where the money goes: at low volume the human review line usually dominates and the software is under a couple of hundred dollars a month; at high volume the model tokens and per-unit meters (minutes, SMS segments, vector reads) take over. The worked examples on this page land at roughly $700-900 a month all-in including review time, but they are illustrative arithmetic on our assumptions, not a benchmark. Build your own from your own run count.
- Why is the input token line bigger than the output line when output costs more per token?
- Because agents send vastly more input than they produce. Every step of an agent loop re-sends the system prompt, the tool definitions, all prior messages and every tool result. A six-step loop can push 40,000 input tokens to generate 1,300 output tokens. Even at OpenAI's published 6x output premium for gpt-5.6-terra ($12.00 vs $2.00 per million), the input volume wins. That is also why prompt caching is the highest-leverage change available - it targets the biggest line.
- Which automation platform is cheapest to run at volume?
- It depends on the shape of your workflow, not on the platform's list price, because the four majors meter different things. Zapier bills per successful action step, Make per module credit, n8n per whole-workflow execution regardless of step count, and Latenode per CPU second of actual run time. A ten-step workflow running 10,000 times is 10,000 units on n8n and potentially tens of thousands on a per-step meter. A one-step workflow that waits 30 seconds on a slow API is cheap on a per-step meter and expensive on a CPU-second meter. Count your workflow in all four units before choosing.
- Does prompt caching really cut the bill by 90%?
- It cuts the price of the cached portion. OpenRouter's documentation lists Anthropic cache reads at 0.1x base input price with writes at 1.25x, and OpenAI's own table shows cached input at $0.20 against $2.00 base for gpt-5.6-terra. So the discount on those tokens is real and large. But it only applies to the repeated prefix, not to output tokens or to genuinely new input, and it applies only when the prefix is byte-identical between requests. Put a timestamp or a user ID early in the system prompt and the cache silently never hits.
- What running costs do people most often forget to budget?
- Five recur: SMS segments (a long message is several charges, plus per-carrier surcharges that Twilio applies automatically), phone number rental as a flat monthly line, vector database read units which scale with how chatty the agent is, tracing units where one conversation generates many billable data points, and human review hours which appear on no invoice at all. Individually small, collectively the difference between a forecast and a surprise.
- Do these running costs go down over time?
- The per-token cost of a given capability has been falling, but that is not the same as your bill falling, because usage tends to grow to meet the lower price and agents consume far more tokens per task than a single model call does. What genuinely does come down is the cost of a workflow you have optimised: caching the prefix, trimming oversized tool outputs, capping loop iterations and routing easy cases to a cheaper model are all one-time pieces of work with a permanent effect on the monthly line. Human review time also drops as the exception rate falls, though it does not reach zero.
- Should I self-host to avoid these costs?
- Self-hosting moves costs rather than removing them. n8n's Community Edition is free software, so the platform meter disappears and you pay for a server instead. Langfuse can be self-hosted the same way. Self-hosting the model itself is a much bigger step: you swap a per-token bill for GPU capacity you pay for whether it is busy or not, plus the operational time to run it. We work through that break-even in our self-host vs API cost post. The general rule is to optimise the managed setup first, because caching and routing frequently shrink the bill below the point where self-hosting pays.
- How accurate are the prices on this page?
- Every figure was read directly from the vendor's own published pricing page in August 2026 and is attributed inline. Two caveats. First, none of these vendors date-stamp their pricing pages, so we can only tell you when we looked. Second, we could not load Anthropic's own pricing page during this research - it failed a certificate check - so the Claude figures quoted here come from OpenRouter's published model pages rather than from Anthropic directly. Re-check any number before it goes into a budget.
If this resonated
Module 02 is the long version of this post.
Eval set, refusal pattern, kill switch. Build it in a weekend.
