Claude Code Pricing 2026: Autonomous Credits and What Changed
TL;DR: Anthropic announced a split between two types of work, then paused it. Under the announced model, interactive human-in-the-loop sessions in the IDE or terminal keep using your plan's standard limits, while autonomous tasks (Agent SDK, claude -p, GitHub Actions) would draw from a new, separate monthly credit specific to your plan, with optional overages at standard API rates once depleted. None of that is live. Since the June 15 pause, everything still draws from your normal subscription limits, exactly as it did before.
The announcement is still worth understanding, because it's the clearest signal yet of how Anthropic intends to price autonomous usage, and because they've said a revised version is coming. Here's how the two buckets were drawn.
Human-in-the-loop work covers your active, hands-on sessions in the Claude Code terminal, IDE, web chat, or Cowork. These continue to draw from your subscription's existing usage limits exactly as they did before.
The major change applies to Autonomous work, which includes tasks run via the Agent SDK, non-interactive CLI commands (claude -p), and the official GitHub Actions integration. This type of usage is now billed against a new, separate monthly credit.
Each plan receives a monthly autonomous credit that refreshes with your billing cycle:
- Pro ($20/month): $20 autonomous credit
- Max 5x ($100/month): $100 autonomous credit
- Max 20x ($200/month): $200 autonomous credit
- Team standard seats: $20; Team premium seats: $100
- Enterprise (usage-based): $20; Enterprise (seat-based premium seats): $200. Seat-based Enterprise standard seats were not eligible to claim the credit at all.
If your autonomous usage exceeds this credit, all autonomous work stops unless you have explicitly enabled "extra usage," which allows overages at standard API rates.
This presents three clear paths forward depending on your workflow. You can keep your autonomous tasks within the new monthly credit limit. You can move autonomous workloads to the Claude API or a platform like Codex. Or you can take a hybrid approach, using Claude Code for interactive coding while offloading long-running jobs elsewhere.
I write about AI coding tools weekly on my Substack. If you want practical setup guides for these workflows, subscribe there.
What changed in the Claude Code pricing update
The change was announced on May 13, 2026 and scheduled to take effect on June 15. It introduced a clear distinction between two types of usage: human-in-the-loop and autonomous. Anthropic paused it on the day it was due to land, so what follows describes the announced model rather than current billing.
Human-in-the-loop usage covers interactive work and continues to be billed against the existing plan's usage limits. This category includes:
| Activity | Category |
|---|---|
| Interactive Claude Code in terminal | Human-in-the-loop |
| IDE integration (VS Code extension) | Human-in-the-loop |
| Claude web chat (claude.ai) | Human-in-the-loop |
| Claude Desktop app | Human-in-the-loop |
| Claude Cowork | Human-in-the-loop |
Autonomous usage is for automated tasks and now draws from a separate monthly autonomous credit. This credit must be claimed once by the user to activate.
| Activity | Category |
|---|---|
| Agent SDK (Python and TypeScript) | Autonomous |
claude -p (non-interactive mode) | Autonomous |
| Claude Code GitHub Actions | Autonomous |
| Third-party apps authenticating via subscription | Autonomous |
The autonomous credit is allocated per user, refreshes monthly with the billing cycle, and does not roll over. Once depleted, autonomous usage stops unless the user has explicitly enabled extra usage.
What counts as autonomous vs human-in-the-loop?
The distinction comes down to whether you are actively controlling the session or whether Claude is running unattended.
| Activity | Category | Credit Impact | Notes |
|---|---|---|---|
| Terminal (Claude Code) | Human-in-the-loop | Uses plan subscription limits | Interactive sessions only |
| IDE integration | Human-in-the-loop | Uses plan subscription limits | VS Code extension, interactive use |
| Web chat | Human-in-the-loop | Uses plan subscription limits | claude.ai conversations |
| Desktop app | Human-in-the-loop | Uses plan subscription limits | Claude Desktop application |
| Cowork | Human-in-the-loop | Uses plan subscription limits | Collaborative sessions |
| Agent SDK | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Applies to Python and TypeScript projects and third-party apps authenticating via your subscription |
claude -p | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Non-interactive CLI mode only |
| GitHub Actions | Autonomous | Draws from monthly autonomous credit first; optional extra usage at API rates after credit | Official Claude Code GitHub Actions integration |
If you are typing commands and reviewing output in real time, that is human-in-the-loop. If you fire off a task and walk away, that is autonomous.
How much do autonomous credits cost?
Each subscription tier includes a matching monthly autonomous credit.
| Plan | Monthly Price | Monthly Autonomous Credit |
|---|---|---|
| Pro | $20 | $20 |
| Max 5x | $100 | $100 |
| Max 20x | $200 | $200 |
| Team (standard seat) | $20/seat | $20 |
| Team (premium seat) | $100/seat | $100 |
| Enterprise (usage-based) | Negotiated | $20 |
| Enterprise (seat-based, premium seat) | Negotiated | $200 |
| Enterprise (seat-based, standard seat) | Negotiated | Not eligible |
A note for Enterprise customers
The Enterprise picture was the messiest part of the announcement, and it's the part most write-ups got wrong. There was no single Enterprise number. Usage-based Enterprise plans would have received $20 per user. Seat-based Enterprise plans would have received $200 on premium seats, and standard seats on seat-based Enterprise plans were not eligible to claim the credit at all, meaning autonomous usage there would have billed as extra usage at API rates from the first token.
That asymmetry is worth remembering even while the change is paused, because it tells you how Anthropic thinks about the tiers. If a version of this ships, an Enterprise admin's first question should be which of the two Enterprise billing shapes their contract sits on, and which seat types their engineers hold, not what the headline credit number is. Confirm with your account team before rolling out Agent SDK or GitHub Actions workflows across a team.
How the credit mechanics work
The rules governing these credits are straightforward.
Per-user, not pooled. Credits belong to individual accounts. They cannot be shared or pooled across teammates.
Refreshes monthly. Your credit resets at the start of each billing cycle. Unused credits do not roll over to the next cycle.
One-time opt-in. You claim your credit through your Claude account once. After that, it refreshes automatically each cycle.
Drains first. Agent SDK usage draws from your monthly credit before any other source.
Overages are opt-in. When your monthly credit runs out, additional autonomous usage flows to extra usage at standard API rates, but only if you have enabled extra usage. If you have not, autonomous work simply stops.
What are your options now?
There are three practical paths forward depending on how you use Claude Code.
Option 1: Stay on Claude and budget autonomous usage within credits
Keep your current Claude subscription and manage autonomous workflows to stay within the new monthly autonomous credit.
Your interactive work remains unchanged. Autonomous tasks draw from a separate, predictable credit pool. You manage a single subscription and can track per-user autonomous spending without separate API keys.
The trade-off is that the autonomous budget is fixed per user and cannot be pooled across a team. Heavy autonomous workflows may stall once the credit is depleted, unless you enable extra usage at API rates.
This option works best if your autonomous usage is light or predictable.
Option 2: Move autonomous workflows to Codex or API
Migrate your autonomous workloads entirely to the Claude API (pay-as-you-go) or to a competing platform like OpenAI's Codex.
This gives you uncapped autonomous compute. No monthly credit limit to worry about. You pay for exactly what you use.
The trade-off is managing a second billing relationship. You lose the simplicity of a single subscription. You also need to evaluate whether Codex's model quality and tooling meet your needs for specific tasks.
This option works best if you run heavy, unpredictable autonomous workloads that regularly exceed the autonomous credit.
Option 3: Hybrid approach
Use your Claude Code subscription for interactive coding. Offload long-running autonomous jobs to the API or Codex.
This captures the best of both worlds. Your interactive experience stays the same. Your autonomous credit covers light automation. Heavier jobs go to a system designed for scale.
The trade-off is complexity. You are managing two systems, two billing models, and two sets of tooling.
Should you change your plan?
The answer depends on your usage pattern.
If most of your work is in the terminal or IDE, nothing changes. Your interactive sessions use the same subscription limits as before. The autonomous credit is a bonus you may never touch.
If you use claude -p or the Agent SDK occasionally, the included autonomous credit will likely cover you. A Pro plan gives you $20 in autonomous credit per month. For occasional scripted tasks, that goes a reasonable distance.
If you run agents overnight or schedule unattended jobs, do the maths. Calculate your typical monthly token consumption for autonomous tasks. Compare it against the autonomous credit included in your plan. If you consistently exhaust the credit, you have two choices: enable extra usage and pay API rates for overages, or migrate those specific workloads to the Claude API directly or to Codex cloud tasks.
If you are on a team, remember that credits are per-user and not pooled. A team of five on Max 5x gets five separate $100 credits, not one $500 pool. Plan accordingly.
If you administer an Enterprise workspace, the picture flips, and it depends on which Enterprise shape you're on. Usage-based Enterprise was set to receive $20 per user; seat-based Enterprise, $200 on premium seats and nothing at all on standard seats. On that last combination every autonomous token would bill as extra usage at API rates from the first call. Confirm your billing shape and seat mix with your account team before you encourage engineers to lean on Agent SDK workflows or claude -p in CI.
For most interactive Claude Code users, the pricing update changes nothing about what they get for their money. It lands on power users who built autonomous pipelines on top of a subscription that was never priced for that level of compute.
If you want help setting up an autonomous coding stack that fits your budget, join the course waitlist. I will email practical modules, examples, and calculators when it opens.