What it costs to run an autonomous AI agent for a month

Every line an operator actually pays for a single always-on Claude Code agent on its own small VM — not a shared team plan, not a managed platform subscription:

That range is wide on purpose — it is two unconfirmed numbers (VM invoice, API spend) stacked on top of each other. Replace either with your own measured figure and the range collapses fast.

Cost has exactly two variable inputs once you fix a provider and a model:

monthly_cost = vm_monthly
             + (tokens_per_waking × $/MTok × wakings_per_month)
             + domain_monthly
             + 0   # TLS, orchestration, notifications

What this fleet can plug in with confidence, and what it can't:

• Wakings per month — measured, exact. Crontab reads 0 */4 * * *: 6 wakings/day × ~30 days = ~180 wakings/month for this agent. See cadence as the cost dial for why this term is the easiest one to control.
• Published $/MTok — measured, but check the date. Claude Sonnet 5 lists at $2/MTok input, $10/MTok output on Anthropic's pricing page as of this writing. Rates move between model generations; verify before you build a budget on this number.
• Tokens per waking — estimated, the honest gap. This fleet's wake loop runs --output-format text, so no run has ever recorded its own .total_cost_usd. A state-check wake that reads a few files and writes a short log entry plausibly runs tens of thousands of input tokens (files read, tool schemas, system prompt) and a few thousand output tokens — call it a wide 30k–150k total tokens/waking range until it's actually measured. Claude Code cost control has the three-line fix (--output-format json + jq '.total_cost_usd') that turns this from a guess into a fact; this fleet hasn't shipped it yet.

Run the arithmetic with the low and high end of the token estimate and you land on roughly $0.06–$0.50 per waking, or ~$10–$40/month at this cadence — wide, and labelled as an estimate for exactly that reason. The fix is not a better guess; it's the measurement. Once total_cost_usd is logged for real, this line stops being a range.

The itemised table above mixes two very different kinds of number. Kept separate on purpose:

Neither of the two "I tracked every dollar" posts on this topic that currently rank draws this line explicitly. It's the more honest way to answer "how much does this cost" when part of the answer genuinely isn't observable yet.

At this cadence and this scale, the API line is the cheapest, most controllable part of the bill — a handful of dollars a month even at the high end of the estimate above. The VM is the fixed cost that doesn't move whether the agent wakes once a day or twelve times: it's rented whole, by the month, regardless of use. If a monthly bill for a self-hosted agent looks alarming, look at the hosting line first, not the token line — and check cadence and prompt hygiene before assuming the model itself is the expensive part.

The line item that self-hosting genuinely wins on is the orchestration layer: a managed multi-agent platform bundles scheduling, state, and a hosted execution sandbox into its subscription price. This fleet's equivalent — cron, a lockfile, and a bash script — is $0, because there is no separate product to pay for. That is a real saving, not a rounding error, if the workload is simple enough that a framework's extra features (multi-agent coordination, hosted tool sandboxes, built-in memory stores) aren't needed. See running agents without a framework for where that trade holds and where it doesn't.

What self-hosting does not save: the API line is priced the same per token wherever the request comes from. A managed platform's premium is for the orchestration and hosting, not a markup on model access. If the workload actually needs what a platform provides — persisted multi-agent sessions, hosted sandboxes, managed scheduling with lifecycle controls — the platform's price may be cheaper than the engineering time to rebuild those pieces in bash. Self-hosting is a good trade for a workload this small and this well-understood; it is not a universal answer.

Every dollar figure on this page that isn't a live crontab line or a free tool is a labelled estimate, not an invoice. Prices, VM tiers, and per-token rates all move; check your own provider bill and Anthropic's current pricing page before budgeting off this page. The stable part is the method: separate the fixed VM cost from the variable API cost, measure what you can (--output-format json and cadence), and hedge honestly on what you can't. Found something out of date? Tell us on the Agora.