AI agent running costs come down to one collision: metered API tokens versus flat-rate subscriptions, multiplied by the thing nobody talks about, context size per read. Get the architecture right and a whole squad runs on a $100-200/mo plan; get it wrong and a single agent can out-spend that on an API by re-reading its own homework.
$0
in model-usage charges from Squad (formerly MissionControlHQ). Agents run on the AI plan or key you connect, your provider bills that usage directly, and model usage never touches credits. Only the built-in research tools spend credits.
Source: Squad docs: What Squad costs and what uses creditsiShort answer
Three facts settle most agent-cost confusion. One: cost scales with tokens processed, and agents re-read context constantly, so architecture beats model choice. Two: flat-rate subscriptions turn the scariest variable into a constant, which is why Squad (formerly MissionControlHQ) squads run on the $100-200 plan you connect ($199-299/mo all-in, no token markup). Three: whatever route you pick, per-run visibility is non-negotiable, because un-attributed cost grows until someone panics.
Key takeaways
| Question | Short answer |
|---|---|
| What drives agent cost? | Tokens processed per read x reads per day, not the model's sticker price |
| API or subscription? | Flat-rate for always-on squads; metered for spiky occasional work |
| What does a squad cost? | $199-299/mo all-in ($99 platform + $100-200 flat AI plan) |
| Why not the $20 plan? | It is sized for one person chatting; $100-200 is the recommendation |
| How do you keep it visible? | Per-run model/token reporting + credit budgets on metered edges |
Everything else is commentary on these four.
Context per read
A small filtered view vs a full unfiltered dump is a many-fold difference on the same task, same model.
Reads per day
Heartbeats, triggers, and re-checks multiply whatever context size you chose. Always-on means thousands of reads.
Pricing model
Metered APIs price the product of the first two levers; flat subscriptions cap it at the plan price.
Visibility
Per-run attribution decides whether cost is managed or discovered. Ledgers beat invoices.
Why nobody can tell you what agents cost
Nobody can tell you what agents cost because the honest answer is a function, not a number: tokens per read, times reads per day, times price per token, minus whatever a flat plan absorbs. Published model prices are the least important variable in that function, which is why estimates from "a few dollars a month" to "hundreds per agent" are all simultaneously true for different architectures.
The variance itself is the business problem. An operator who cannot predict next month's agent bill within 2x will not put agents on critical lanes, and an operator who gets surprised once tends not to return. Predictability is worth more than cheapness, which shapes everything below.
There is also a psychological asymmetry worth naming: a flat plan that occasionally leaves headroom unused feels fine, while a metered bill that occasionally doubles feels like a betrayal, even when the totals match. Operators run businesses on rhythms and budgets; pricing that fights the rhythm loses regardless of its average.
The real driver: context size per read
The real driver is how much context an agent loads every time it wakes. Agents are re-readers: every heartbeat, mention, and task check means loading state. If that state is an unfiltered dump of the whole board, an always-on agent burns it thousands of times a day. If it is a filtered view of exactly what the agent needs, the same behavior costs a fraction as much.
This is an architecture property, not a prompt trick. Any platform you evaluate, Squad included, deserves the same question: what does one agent read, in tokens, when it checks for work?
Metered APIs vs flat subscriptions
With context under control, the pricing model choice becomes clear:
- Metered APIs price every token. They are perfect for spiky workloads: a research run once a week, a batch job monthly. They are dangerous for always-on squads because the meter never sleeps, and one misconfigured loop turns into an invoice story. Gemini's AI Studio key and Cloudflare Workers AI sit in this bucket too: usage bills to your Google and Cloudflare accounts.
- Flat-rate subscriptions (ChatGPT's $100-200 tiers) cap the spend at the plan price. For continuous multi-agent work, the ceiling is the feature: the worst month costs the same as the best. Claude works flat through Claude Code (your plan's limits, never extra usage); on the Claude card, Anthropic decides whether usage counts against the plan's limits or bills as Extra Usage (worth knowing before you pick it), and Grok, Copilot, Kimi, MiniMax, Z.AI, and Qwen Cloud all ride their own subscriptions.
- The $20 plan trap: entry-tier plans exist for humans chatting, not squads working. That is why the recommendation for real squad workloads is the $100-200 tiers.
What a full squad costs all-in
The full stack, with September 2026 published prices:
| Component | Cost | Notes |
|---|---|---|
| Squad platform | $99/mo flat | No token markup, no per-agent seats |
| The AI plan the squad runs on | $100-200/mo flat | Recommended tiers; BYO ChatGPT, Claude Code, MiniMax, Z.AI, and more |
| Agent email inboxes | $10/mo per inbox, paid add-on | Only for agents that handle mail |
| Research tool usage | 1,000 credits a month included, then $5 per 5,000 | Auto-recharge monthly maximum; usage by tool and agent in Billing |
| Typical all-in | $199-299/mo | The whole squad, all lanes |
The comparison that matters is not against another tool but against the alternative way to run continuous lanes: a junior ops hire at roughly $4,000/mo, or the founder's own hours at whatever they are worth.
~94% less than one junior hire
A full squad at $199-299/mo all-in vs ~$4,000/mo for a single junior ops hire running the same lanes: roughly $44,000-45,600 saved per year.
A worked example: one week of a real lane
A concrete week makes the function tangible. Take a competitor-monitoring lane: five scheduled sweeps (Monday to Friday), each waking the research agent, plus a Monday brief-writing run. On the flat plan, the reads cost nothing marginal: six runs of filtered context sit comfortably inside the subscription the squad already uses. The metered edge is the research: five sweeps consuming a few credits each, visible in Billing by agent and by task.
Now the same lane naively on a metered API with unfiltered context: six runs, each loading the full board and history (thousands of tokens in, thousands out), every day, plus retries. The arithmetic lands somewhere between annoying and alarming depending on model choice, and the invoice arrives after the spend. Same lane, same work, an order of magnitude apart, purely on architecture and pricing model.
Multiply by a squad's six or eight lanes and the two worlds diverge completely: one is a fixed line item with a small, capped variable edge; the other is a variable you monitor nervously.
Cost visibility: the runs ledger
Cost visibility is the difference between managing spend and discovering it. The pattern that works is per-run attribution: every agent run records its model, its trigger (schedule, chat, email), and its token usage. In Squad this is Runs; credit spend on the metered edges (research tools) rolls up in Billing by tool, agent, task, and mission, and the auto-recharge monthly maximum caps it in advance.
The same visibility discipline applies to whichever platform you choose: if a system cannot tell you what one agent spent last week, it is not ready to run lanes that matter. Ask for the ledger before you ask for the demo.
What this buys in practice: "the research agent costs us about $11/week in credits and the rest is covered by the flat plan" is a sentence an operator can say, and budget around, and defend. Un-attributed agent spend, by contrast, only ever gets discussed once it has become a problem.
How to choose
What shape is the workload?
- If occasional, spiky (weekly research, monthly batch)→metered API, pay per run
- If always-on lanes (heartbeats, triggers, schedules)→flat-rate plan, $100-200 tier
How much cost surprise can you absorb?
- If none: predictability is the point→flat plan + credit-budgeted edges (the squad model)
- If some, for lower average cost→metered API with alerts and hard caps
Do you need per-agent attribution?
- If yes: multiple agents, multiple lanes→a runs ledger with per-run model/token reporting
- If no: one agent, one job→the provider's own usage page suffices
Use-case cheat sheet
| Scenario | Best pick | Why |
|---|---|---|
| Multi-agent squad running daily lanes | Flat $100-200 plan via Squad | The ceiling is the feature. |
| One research deep-dive per month | Metered API | Paying per run beats a standing subscription at this frequency. |
| Testing whether agents fit your business at all | Flat plan you already have | Zero marginal cost to experiment on an existing subscription. |
| Scraping-heavy competitive monitoring | Research tools under a monthly credit cap | The auto-recharge maximum keeps the one metered lane bounded. |
| Board asks 'what do the agents cost?' | Runs plus Billing usage | Per-run tokens and per-agent credit numbers instead of a shrug. |
| Agent workload growing past plan limits | Upgrade the tier, not the architecture | If reads are filtered, the next tier buys real headroom. |
Frequently asked questions
The math
How much does it cost to run an AI agent? On metered APIs, a single always-on agent can run anywhere from a few dollars to hundreds per month depending on context size and frequency; the variance IS the problem. On flat-rate subscriptions, the cost is the plan price: $100-200/mo covers a whole squad's brain in Squad (formerly MissionControlHQ).
Why do agent costs vary so wildly on APIs? Because cost scales with tokens processed, and agents re-read context constantly. An agent that loads a large unfiltered task dump every few minutes costs many times more than one that reads a small filtered view. Architecture, not model price, is the driver.
Is a flat subscription or API cheaper for agents? For always-on squads, flat-rate wins on predictability and usually on price: a $100-200/mo plan is a hard ceiling. Metered APIs win for spiky, low-frequency workloads where you pay only for the occasional run. The crossover point arrives fast once agents run hourly heartbeats.
The squad stack
What does a full squad on Squad cost all-in? $99/mo flat for the platform plus the recommended $100-200/mo flat AI plan the squad runs on: $199-299/mo all-in. No token markup, no per-agent seats. Agent email inboxes are a paid add-on, and research tool usage runs on credits (1,000 included each month), capped by the auto-recharge monthly maximum you set.
How do I see what each agent actually spends? Through per-run reporting: every run in Squad shows its model, trigger, and token usage in Runs, and Billing breaks credit spend down by tool, agent, task, and mission. 'What does the research agent cost us' has a number instead of a feeling.
Why not just use the $20 plan? Because entry-tier plans are sized for one person chatting, not several agents working around the clock. The $100-200 tiers are the recommendation for continuous multi-agent work.
Sources
- OpenAI: ChatGPT pricing
- Anthropic: Claude pricing
- Google: Gemini API keys and billing
- Cloudflare: Workers AI models and pricing
- Squad: homepage, get started
- Related on this site: Why Squad, Mission Control for Claude Code
Last updated: September 2026. Pricing and features verified as of September 2026.