'AI Agent Pricing Glossary: ACUs, Tokens, Seats, and Tasks Defined for Buyers'

Last week I watched a founder spend 40 minutes on a call trying to figure out whether Devin's compute minutes would cost more than Cursor's per-seat plus his OpenAI API bill. He had three spreadsheets open. He still got it wrong.

I've been there. More times than I'd like to admit.

That's the state of AI agent pricing in 2026. Every vendor invented their own billing unit. ACUs. Compute minutes. Task credits. Inference tokens. Agent seats. Some charge per-model-call, some per-completed-task, some per-user-per-month, and a few charge all three simultaneously. It's maddening — and if you're tracking ad spend ROI with analytics tools, adding unpredictable AI costs makes forecasting even harder.

This glossary is the reference I built while researching pricing models for DevOS. Every term buyers encounter when comparing AI coding agents, agent platforms, and agentic infrastructure — defined without the marketing spin. Cross-reference this when vendor pricing pages start sounding like word salad. (They usually do.)

Per-Seat Pricing

What it means: A flat monthly fee for each user (seat) who can access the AI agent or platform. Doesn't matter how much the agent works — you pay for access.

This is the model most SaaS buyers already understand. GitHub Copilot charges $19/month per user for the Individual plan, $39/user/month for Business. Cursor charges $20/month per seat for Pro. Linear is $10/user/month. Simple.

The tradeoff: predictability vs. efficiency. You know exactly what you'll pay next month. But if your agents sit idle (or you have seats assigned to people who barely use them), you're paying for unused capacity. Been there too — discovered we were paying for 8 seats when only 3 people logged in monthly.

For agent platforms where agents work as employees — taking tickets, opening PRs, handling deploys — per-seat pricing usually applies to human seats. The agents themselves are billed differently. DevOS's planned pricing works this way: $25/user/month for Pro (waitlist), unlimited AI agents included. You pay for humans; agents are infrastructure.

Watch for: "Per-seat" where the "seat" is the agent, not the human. Some vendors charge per-agent-instance, which scales very differently.

Per-Task Pricing

What it means: Charges based on work completed. A "task" might be a ticket resolved, a PR merged, a deployment run, or an issue triaged. You pay for outcomes, not access.

This sounds ideal — only pay when agents produce value. But the devil's in the definition. What counts as one task? If an agent picks up a ticket, makes a partial fix, gets stuck, and a human finishes it — is that one task? Half a task? Zero?

Per-task pricing works best when tasks are atomic and clearly defined. CI/CD runs. Test suite executions. Code reviews on PRs. It gets messy for knowledge work like "implement this feature" where scope varies 10x between tickets.

Honestly? I think per-task billing is a trap for most teams. You end up gaming the system — splitting work into smaller "tasks" to hit quotas, or avoiding agent use because the meter's running.

Real example: Some QA automation platforms charge per test run or per test minute. A 500-test suite running 3x daily is 1,500 billable tasks per day — 45,000/month. That math can surprise you. (If you're dealing with click fraud eating your ad budget, you know how fast hidden costs compound.)

Watch for: Minimum task charges, task retry billing (does a failed attempt count?), and narrow task definitions that turn one intuitive "task" into five billable ones.

Token-Based Pricing

What it means: Billing based on the fundamental unit of LLM inference — tokens. Roughly 0.75 words per token. Every prompt and response costs tokens.

This is how the model providers themselves charge. Flagship models cost significantly more than budget models — we're talking 10-50x price differences between tiers. Output tokens typically cost 3-5x more than input tokens across providers. Check each provider's current pricing page; these numbers shift frequently.

For AI agents, token costs matter because agents are chatty. A coding agent might consume 50-100K tokens per ticket — reading files, writing code, iterating on errors, generating tests. At flagship-tier pricing, that adds up fast. Multiply by hundreds of tickets per sprint and you'll understand why model routing matters.

Most agent platforms abstract tokens away. You don't see the token bill directly — it's bundled into compute units, task credits, or flat pricing. But tokens are always the underlying cost driver. When platforms change pricing, it's usually because model costs shifted.

Watch for: Which model the agent uses by default. Platforms routing to expensive models burn through token budgets fast. Multi-model routing (like DevOS plans to offer) picks cheaper models for simple tasks.

ACUs (Agent Compute Units)

What it means: A vendor-specific abstraction that bundles multiple resources into one billable unit. "1 ACU" might equal X minutes of compute + Y tokens + Z tool calls.

ACUs are the vendor's attempt to simplify billing. Instead of tracking tokens, compute, storage, and API calls separately, you buy ACU bundles and the platform handles allocation.

The problem: every vendor defines ACUs differently. AWS Bedrock Agents has usage-based pricing per model invocation. Azure AI Agent Service bills per "agent message." Anthropic's Claude API doesn't use ACUs at all — direct token billing. Google Vertex AI Agents charges per prediction and per custom model training hour.

When a vendor says "100 ACUs included," your first question should be: "What's the conversion formula?" If they can't give you a straight answer — and in my experience, most can't — assume the math favors them, not you.

Watch for: ACU "buckets" that expire monthly, ACU overage rates that spike 3-5x the in-bundle cost, and activities that consume ACUs faster than expected (multi-step reasoning, long-context operations, tool-heavy workflows).

Compute Minutes / Compute Credits

What it means: Billing based on wall-clock time the agent runs. Not token count, not task count — literally how many minutes the agent is "working."

Devin uses this model. You buy compute time; the agent consumes it while active. Simple to understand, but it creates weird incentives. A fast agent that solves tickets in 10 minutes costs half as much as a thorough agent that takes 20 — even if the thorough one produces better code.

Compute minutes also vary by what the agent does while the clock runs. If it's waiting on CI to finish, that's billable compute. If it's reading a large codebase, that's billable compute. The meter runs whenever the agent isn't idle.

Real example: If an agent platform charges (hypothetically) $0.50/compute-minute and your average ticket takes 25 minutes of agent time, you're paying $12.50/ticket. Ship 200 tickets/month and you're at $2,500 — before any human seats or infrastructure costs. Ouch.

Watch for: Background processes that keep the meter running, inefficient agents that spin longer than necessary, and "compute" that includes idle waiting (for CI, for human review, for API responses).

Inference Costs

What it means: The direct cost of running prompts through an AI model. Usually measured in tokens (input and output separately) and billed per million.

This is the "raw materials" cost of any AI agent. The platform's inference bill determines the floor of what they can charge you. If their flagship model costs X per million tokens and they're charging you less... something's being subsidized (probably by investor money). That subsidy won't last forever.

Inference costs matter most for:

• Self-hosted agents: You pay model providers directly
• Token-passthrough pricing: Platform charges you exactly what they pay, plus margin
• BYO-key setups: Bring your own API keys, pay your own inference bill

Most managed platforms bundle inference into their pricing. You don't see the breakdown. But understanding inference costs helps you evaluate whether a platform's pricing is sustainable — and whether they'll have to raise it. Just like call tracking platforms bundle per-minute costs differently, AI agent platforms obscure the true unit economics.

Watch for: Input vs. output token pricing (outputs usually cost 3-5x more), context length penalties (some models charge more for long contexts), and image/multimodal inference (way more expensive than text).

Model Routing Costs

What it means: Price differences based on which AI model handles a given request. Platforms with multi-model routing send simple tasks to cheap models and hard tasks to expensive ones.

The spread is significant. Cheaper models run a fraction of what flagship models cost — we're talking 10-60x differences depending on provider and tier. An agent platform routing intelligently can serve 80% of requests at budget prices while only burning premium tokens on the 20% that genuinely need it.

DevOS's planned multi-model routing across Anthropic, Google, DeepSeek, and OpenAI is designed for this. The orchestrator evaluates task complexity and picks the cheapest capable model. Simple code formatting? Haiku. Complex architecture decisions? Opus.

Watch for: Platforms that default to expensive models for everything (easy sell: "powered by GPT-4o" but expensive to run), hidden model selection (you don't know what's routing where), and no control over routing preferences.

Tool Execution Costs

What it means: Charges for actions the agent takes beyond model inference — running code, calling APIs, executing commands, accessing databases.

Some platforms charge for tool use separately. Each git push, each test run, each API call might be a billable event. This is especially common for agents with computer-use capabilities (controlling a browser/GUI) since those are resource-intensive.

This one frustrates me. Tool execution is where agents actually do things — and some vendors treat it as a premium add-on.

For coding agents, tool execution includes: reading files from repos, writing files, running tests, executing builds, deploying to staging, querying databases. Heavy tool use can double or triple the cost compared to pure inference.

Watch for: Sandboxed execution costs (running untrusted code safely costs more), external API passthrough charges, and tool-time vs. inference-time (some platforms bill these separately at different rates).

Flat-Rate / Unlimited Pricing

What it means: One price, no usage limits. Or more accurately: one price, soft usage limits buried in terms of service.

"Unlimited" in AI agent pricing almost never means infinite. It means: we won't charge you per unit, but we reserve the right to throttle or terminate if you exceed fair use. GitHub Copilot's $19/mo individual plan is "unlimited completions" — but if you somehow generated 10 million completions a month, you'd hear from their abuse team.

Flat-rate is great for budgeting and removes the anxiety of watching meters tick. It's less great if you're a light user subsidizing heavy users, or if the platform's model costs spike and they have to claw back usage through stricter throttling.

Watch for: Fair-use clauses in ToS, "unlimited*" with asterisks, throttling thresholds that aren't disclosed, and rate limits that kick in under load.

Hybrid Pricing

What it means: Multiple billing dimensions combined. Per-seat base + per-task overage. Flat rate + token passthrough above a cap. Compute credits included + ACU add-ons.

Most production-ready agent platforms use hybrid models. The base fee covers infrastructure and some usage; usage-based components kick in at scale. This balances predictability (you know the minimum) with scalability (heavy users pay proportionally).

Real example: A hypothetical agent platform might charge $50/user/month (seats), which includes 1,000 tasks. Tasks 1,001+ are $0.10 each. You know your floor but can burst higher.

Watch for: How the different dimensions interact. Does heavy task usage consume your included tokens faster? Do compute minutes count against ACU limits? Hybrid models can be transparent or can be designed to obscure true costs.

Credit Systems

What it means: Pre-purchased usage units (credits) that draw down as you use the platform. Often sold in bundles with volume discounts.

Credits are common in API-first platforms. Buy $1,000 in credits, use them until they're gone. Some credits expire (use-it-or-lose-it monthly), some don't. Volume tiers give discounts: $10K gets you 15% more credits than $1K.

The psychology matters. Credits feel like spending "play money" — it's harder to track real costs compared to direct billing. Good for cash flow (pre-pay), bad for cost visibility (easy to burn through without noticing).

I'll admit: I've fallen for this. Bought a credit bundle, felt rich, then watched it evaporate in two weeks because I didn't track consumption. (This is why proper analytics dashboards matter — you need visibility into where spend goes.)

Watch for: Credit expiration policies, hidden fees that drain credits faster (support, storage, premium features), and credit-to-dollar conversion rates that change with pricing updates.

Honorable Mentions

MAUs (Monthly Active Users): Some platforms charge based on how many end users interact with your AI features. Relevant if you're building AI into a product, less relevant for internal dev tooling.

GPU-hours: Raw compute time on accelerator hardware. Direct cloud pricing (AWS, GCP, Azure). Most agent platforms abstract this away, but it's the underlying cost for any self-hosted model.

Context window costs: Some providers charge premium rates for using full context windows. Filling Claude's 200K context costs more per-token than using 10K context on the same model.

Egress/transfer fees: Moving data in and out of the platform. Usually small, occasionally nasty surprises at scale.

Quick Verdict

If you're comparing AI agent platforms: ask for the conversion formula. Every vendor. Don't be polite about it.

When they say "100 ACUs included," ask: how many tasks is that? How many tokens? How many minutes of compute? If they can't tell you — or won't — assume the pricing is designed to favor them, not you. I've walked away from three vendor calls this year over exactly this.

For most teams just starting with AI agents, per-seat pricing with unlimited (soft-capped) agent usage is simplest. You know the monthly number. You budget around it. You don't watch meters. DevOS's planned Pro tier at $25/user/month (waitlist) with unlimited AI agents is designed for that simplicity.

Per-task and token-based billing make sense once you have enough volume to predict usage — and enough cost data to optimize. Until then, predictability beats optimization. Check out the DevOS blog for more guides on AI agent infrastructure as we build in public.

Frequently Asked Questions

What is the difference between per-seat and per-task AI agent pricing?

Per-seat pricing charges a flat monthly fee for each user who can access the AI agent — predictable costs but you pay whether the agent works or sits idle. Per-task pricing charges based on actual work completed (tickets resolved, PRs opened, deploys run). Per-task is cheaper if agents work sporadically but unpredictable at scale. Most teams starting with AI agents prefer per-seat for budgeting simplicity.

What are ACUs in AI agent billing?

ACUs (Agent Compute Units) are a vendor-specific abstraction bundling compute time, model calls, and tool executions into one billable unit. One ACU might equal 10 minutes of agent runtime plus 50K tokens plus 20 tool calls — but the ratio varies by vendor. Always ask for the conversion formula before committing. ACUs simplify billing but obscure underlying costs.

How do tokens affect AI agent pricing?

Tokens are the base unit of model billing — roughly 0.75 words each. Every prompt and response costs tokens; pricing varies widely by model tier, with flagship models costing 10-50x more than budget options. Agent platforms either pass through token costs directly, bundle them into compute units, or absorb them into flat pricing. Token-heavy workflows (long context, lots of code) get expensive fast.

What does 'unlimited tasks' mean in AI agent pricing?

Usually 'unlimited tasks with fair-use limits' — the vendor won't charge per task but reserves the right to throttle or block extreme usage. Read the terms. Some platforms define tasks narrowly (only completed tickets count) while others count every action. Unlimited rarely means infinite — it means the limit is hidden in the ToS instead of the pricing page.

---

Join the DevOS Waitlist

AI agents that work as employees inside your sprints, standups, and tickets — not single-task copilots. Planner / Developer / QA / DevOps agents pick up work from the backlog, ship in branches, request review. Linear-shaped backlog UI with AI underneath. Pre-launch.

Join the waitlist → · How agents-as-employees works