ide.tools

Pricing field guide

AI coding agent pricing without false monthly comparisons

A practical guide to comparing AI coding-agent subscriptions, credits, provider usage, seats, and execution costs without pretending incompatible billing units are equal.

By Ros · Published · Updated

Why the first number lies

AI development tools publish prices in units that look comparable and are not. One plan buys an editor seat, another buys a rolling usage window, another includes a credit pool, and another provides only the agent harness while a model provider sends a separate bill.

That does not make pricing unknowable. It means the comparison must begin with the billing shape and the actual workflow—not a row of monthly numbers.

Five costs in one stack

1. Working surface

An AI-native editor can include completion and interactive agents in one subscription. An extension may preserve the editor you already own. A terminal agent may have no editor cost at all. Do not count those as equivalent merely because each can edit code.

2. Model access

Hosted plans may bundle access, meter it through credits, or stop at a rolling limit. Bring-your-own-key tools shift the bill to the model provider. Local-model support avoids an external inference bill but introduces hardware and operating costs.

3. Agent execution

Local agents consume the developer’s machine and time. Cloud agents can add sandbox, compute, storage, or task charges. The cost of keeping ten tasks running is not implied by the price of one interactive seat.

4. Coordination

Worktree managers, orchestrators, review gates, and merge automation can be separate products or features inside a larger platform. Include them when the proposed workflow depends on them.

5. Review and failure

The largest hidden cost is engineering correction. A cheaper plan that produces larger, less trustworthy diffs can lose to a more expensive tool after review time is counted.

Billing shapes and failure modes

Fixed subscription: easiest to approve, but “included” usage can still have product-specific limits or fair-use boundaries.

Subscription plus usage: predictable access fee, variable heavy-use bill. Spend caps matter more than the headline plan price.

Credit pool: visible quantity, unclear work equivalence. Model choice and task complexity can change credit consumption.

Provider-key usage: portable and transparent at the token level, but context-heavy agent loops can make per-request intuition unreliable.

Free open-source client: the software price is zero; inference, hardware, setup, and maintenance are not.

Three scenarios to model

Light individual

Mostly completion and short interactive changes. Record subscription cost, included usage, and whether the free lane is operationally sufficient.

Agent-heavy individual

Several multi-file tasks per day, long context, repeated test loops, and occasional background work. Track interruptions, reloads, overages, and the cost of a second subscription used as overflow.

Ten-person team

Include seats, shared or individual usage pools, administration, SSO, policy, support, and the cost of standardizing instructions and review. Separate active agent users from developers who only need completion.

A reproducible trial

Run the same three bounded tasks for one working week. For each product, record:

  • access path and plan;
  • model selected;
  • task starts and completed tasks;
  • interruptions or limit resets;
  • extra usage purchased;
  • reviewer minutes and required corrections;
  • infrastructure or orchestration used outside the product.

Publish the assumptions beside the result. A single “cost per task” number without workload, model, and review context is another false comparison.

Practical recommendation

Start with the smallest plan that can execute the real trial. Set hard spend limits where supported. Standardize only after the team can explain its total stack cost and what happens during a heavy week.

Primary sources