AI Agent Pricing Decoded: Per-Seat vs. Per-Action vs. Per-Outcome

The short version

Agent platforms now price four different ways, and they are not comparable without doing the math on your own usage:

• Per-seat — you pay per person. Predictable. Increasingly rare for agents.
• Per-action — you pay per discrete thing the agent does. Salesforce Agentforce charges about $0.10 per standard action, $0.15 for voice.
• Per-conversation — a flat rate per interaction regardless of complexity. Agentforce offers $2/conversation as an alternative.
• Per-outcome — you pay only when the agent resolves the issue. Sierra sells this way.
• Pass-through — no platform fee, you pay model costs. OpenAI's AgentKit works this way.

The trap is in the definitions, not the numbers. Read on for the one that catches almost everybody.

The token ceiling nobody models

Agentforce Flex Credits work out to $500 per 100,000 credits, with a standard action costing 20 credits ($0.10) and a voice action 30 credits ($0.15). Straightforward enough.

Here is the part buried in the documentation: one action covers up to 10,000 tokens. Cross that and it bills as two actions.

So an action that consumes 15,000 tokens costs $0.20, not $0.10. If your agent does retrieval-heavy work with large context — which is exactly what useful enterprise agents do — a meaningful share of your actions will exceed the ceiling. Your real cost per action is not $0.10, and your model that assumed it was is wrong by however much long-context work you do.

There is a break-even worth knowing: the $2-per-conversation option beats Flex Credits once your average conversation exceeds 20 actions. Which model is cheaper depends entirely on the shape of your traffic, so pull real transcripts and count.

Credit metering: the general problem

Microsoft Copilot Studio meters in Copilot Credits, consumed per agent action or response, sold three ways — bundled with Microsoft 365 Copilot at $30/user/month, pre-purchased as Credit Commit Units at up to 20% savings, or pay-as-you-go. Gumloop sells 20,000 credits at $37/month with an additional 8% orchestration fee on top. Lovable gives you 5 credits a day free, 100/month at $25, with each prompt burning a variable number depending on complexity.

The pattern across all of them: a credit is a unit whose cost in real work is variable and only knowable after you have used it. That is not necessarily unfair — the vendor's cost is genuinely variable too — but it makes budgeting hard in a specific way that catches finance teams off guard.

Two defenses:

1. Run a metered pilot before you commit to a plan tier. Take a real workflow, run it 50 times, measure credits consumed. Extrapolate from that, never from the vendor's example. 2. Ask what happens at the ceiling. Does it hard-stop, throttle, or auto-purchase more? Auto-purchase is the setting that produces the surprise invoice.

Outcome pricing is the most interesting and the hardest to negotiate

Sierra charges per resolved issue rather than per conversation or per seat. Strategically this is the most vendor-aligned model in the market: the vendor only gets paid when the thing works, which is the opposite of how support software has historically been sold.

The catch is definitional. What counts as a resolution?

• Does a conversation that ends without escalation count, even if the customer was not actually helped?
• Does a customer who comes back tomorrow with the same problem count as one resolution or two?
• Who adjudicates a disputed case?
• Does a deflection to a self-service article count?

These are negotiated terms, not settled industry standards. Outcome pricing is genuinely good, and it requires more legal attention than a per-seat contract, not less. Budget for that in your evaluation timeline.

Pass-through pricing: cheapest sticker, real lock-in

OpenAI's AgentKit charges no platform fee. Designing in Agent Builder is free; you pay standard API rates for execution. As a reference point, GPT-5.2 runs roughly $1.75 per million input tokens and $14 per million output, with GPT-5 mini around $0.25 per million input.

That is the most legible cost model available, because it is the API cost model you already forecast. The price is lock-in at the orchestration layer — your agent definitions live inside one provider's tooling. Whether that matters depends on how likely you are to switch models, which in a market moving this fast is not a hypothetical. Gateway layers like LiteLLM, Portkey, and OpenRouter exist precisely to keep that option open.

AWS Bedrock AgentCore takes the framework-agnostic route instead: bring LangGraph, CrewAI, or your own loop, and pay consumption pricing across the runtime services. Cheaper on lock-in, harder to forecast.

How to actually compare an agent quote

Do this before you talk to any vendor, then do it again with their real numbers:

1. Count your volume in the vendor's unit. Not conversations if they bill actions. Pull 100 real interactions and count actions, tokens, and resolutions in each. 2. Find the ceiling clauses. Token limits per action, concurrency caps, overage rates, and what happens when you hit them. 3. Model three scenarios. Expected volume, 3x volume, and your worst month. Vendors quote the first. Your CFO cares about the third. 4. Price the escalations. In deflection workflows, an escalated interaction costs *more* than baseline, because the agent time is additive to the human time. Deflection savings are always net of this, and quotes rarely say so. 5. Add the implementation cost. Integration, testing, change management. For enterprise deployments this frequently exceeds year-one platform cost.

The honest summary

There is no best model, only a best fit for your traffic shape:

• High volume, simple interactions → per-conversation or per-outcome. Per-action punishes you for chattiness.
• Low volume, complex interactions → per-action, but model the token ceiling carefully.
• Building your own product on top → pass-through, with a gateway layer to preserve optionality.
• Already deep in one platform's ecosystem → their native pricing, because the integration savings usually dominate the per-unit difference.

Compare the platforms side by side in the tools directory, and if you want the evaluation framework rather than the pricing one, start with build vs. buy for enterprise AI agents.