What 11 AI coding plans delivered in our setup

We compared 11 AI coding plans in our own development setup and chose four to keep. Some rows use provider or local-session telemetry; others are estimates from serialized sessions. The comparison describes our workload and billing windows. It does not establish which plan will deliver the best work for another team.

The short version: four subscriptions are worth keeping. Codex delivered roughly 22 billion tokens in a single month — about $14,000 of API-equivalent compute on $150-250 of subscription spend. MiniMax, Devin and Factory Droid each returned somewhere between 15x and 55x. The remaining plans were positive on paper but ran out of quota, expired, or turned out to be reselling the same open-weight models we were already getting elsewhere.^[1][5]

How did we measure real token throughput?

All agent traffic in our setup flows through an LLM proxy plus the agents' own local session logs. That gives us per-provider request counts, model names, and token totals — including cache reads, which dominate agentic coding workloads because each turn resends the accumulated context. Token counts are therefore 'total context processed', not just novel input plus output.

Three honesty constraints before the numbers. First, everything is approximate: where providers don't export token telemetry (Factory Droid, SuperGrok, Cursor), we estimated from serialized session content and cumulative context resend. Second, 'value' means API-equivalent cost — what those tokens would have cost at published per-million-token API rates — not what they cost the provider to serve, and not a guarantee you'd have paid for them otherwise. Third, some subscriptions involved multiple accounts; the Codex row, for example, aggregates several ChatGPT accounts, and we folded the combined cost into the denominator.

One important disclaimer: these numbers measure throughput, not worth. They say nothing about model quality, harness quality, or how good the experience of using each tool actually is. This is pure token volume. The mix was real — smart models doing orchestration, workhorses doing the grinding. A billion tokens of a mediocre model is still a billion tokens of a mediocre model.

Each row in the table reflects that plan's best billing month, since most of these subscriptions were only alive for one or two cycles.

What did eleven subscriptions deliver?

The full audit, best billing month per plan. Token totals include cache reads, which dominate agentic coding traffic.^{[1][2][3][4][5]}

• Codex — ~$150-250/mo across stacked ChatGPT accounts: ~22.0B tokens in August, ~120M tokens per dollar, roughly 60-95x API-equivalent ROI. Mostly gpt-5.6-class models.
• Devin Pro — $20/mo: ~5.16B tokens (4.90B on temporarily-free core models, 0.26B metered), ~48x. SWE-2 did the bulk of the work.
• Factory Droid (estimated) - $20/mo: approximately 3.0B tokens, roughly 55x API-equivalent value. We estimated throughput from serialized sessions; model-pool interpretation is not a provider billing report.
• MiniMax Plus — $20/mo: ~6.78B tokens, ~15x. MiniMax's own M3 model, sustained across two full billing months — the only subscription that never throttled us.
• Cursor Pro (estimated) - $20/mo: approximately 0.35B tokens, roughly 10x API-equivalent value. Estimated from serialized sessions, predominantly Composer in our local selection history.
• GLM Coding Lite — ~$16/mo: ~0.71B tokens, ~10x.
• SuperGrok (estimated) - $30/mo: approximately 0.40B tokens before our quota limit, roughly 10x API-equivalent value. Estimated from serialized sessions.
• Alibaba Token Plan — $18/mo: ~0.49B tokens, ~7x.
• ClinePass — ~$6.41/mo: ~0.71B tokens, ~5x.
• BytePlus Lite — $10/mo: ~0.24B tokens, ~2.7x.
• Mistral — ~$8/mo: ~0.06B tokens, ~10x — positive but negligible volume.

Which four did we keep?

Codex provided the largest recorded volume in our setup: about 22 billion tokens in one best-month window across several accounts. Most of that volume was repeated context and cache reads. The API-equivalent comparison is a way to describe that workload, not cash saved or a measure of accepted software.

MiniMax is the quiet workhorse. The $20 token plan served 6.8 billion tokens of M3 — not the smartest model in the stack, but capable of carrying almost any delegated workload, and the only plan that kept serving at volume for two consecutive months without hitting a wall. If a subscription's job is to absorb grind, this is the one that showed up every day.^[5]

Devin and Factory Droid combined external models with their own model pools. Temporary free or subsidised access affected our best-month comparisons. Treat those conditions as historical observations; do not assume the same allowance will remain available.^[2][3]

Cursor deserves an honest note: at ~0.35B tokens it did better per dollar than most of 'the rest', and we suspect we underused it — the bulk of that volume was their internal Composer model, which is priced into the plan almost as an afterthought.^[4]

Why did the other seven fall short for us?

In our setup, the remaining plans encountered quota limits, expired access or too little usable capacity for the delegated workload. Some proxy requests continued after access expired. That is a monitoring and stop-condition failure to fix in our own tooling, rather than a reason to keep retrying failed requests.^[10]

SuperGrok reached its limit within a day or two of one heavy thread in our setup. That observation concerns a particular workload and billing window, not a general promise about the plan.^[6]

Are these plans secretly serving the same models?

Our model-selection logs showed overlapping open-weight models across several subscriptions. Model names in a local log are useful selection evidence; they do not establish a vendor's full serving architecture. Compare the model you actually selected, usable limits and accepted results before renewing.^[7][8][9]

What does the subscription layer say about the frontier?

This comparison is a snapshot of our operating setup. It does not establish a general market ranking or the economics of a provider's infrastructure. Prices, models and allowances change; check current official terms before making a purchase.

Which plan should you actually buy?

• Start with the workload and the quality you need. A plan that produces more tokens is not necessarily producing more accepted work.
• Assign bounded work to a model that meets its acceptance checks. Include review time and failed attempts in the cost.
• Separate fresh input, cache reads and output in your usage records. Mark estimates explicitly.
• Check current official plan limits and the selected model before paying or renewing.
• Treat temporary free or subsidised access as a changing condition. Stop retries when access or quota is exhausted.

For procurement, pair usage evidence with accepted changes, quality, human review time and delivery cost. This is measurement discipline from our own product development; it is not a consulting-client case study.^[11][13]

We're keeping four subscriptions and letting the rest expire. Yes, that's still a subscription problem — but at least now it's a measured one.^[12][14]