Tygart Media

Tag: AI Models 2026

  • What We Learned Querying 54 LLMs About Themselves (For $1.99 on OpenRouter)

    What We Learned Querying 54 LLMs About Themselves (For $1.99 on OpenRouter)

    The headline: In mid-May 2026, we ran an autonomous OpenRouter session querying 54 LLMs about their own identity, capabilities, and training. Total cost: $1.99 against a $270 starting balance. 43 substantive responses, 10 documented failures, 1 reasoning-only response. The most interesting finding: aion-2.0 identified itself as Claude — concrete evidence of training-data identity inheritance across LLMs. This article walks through the methodology, the reliability data, and what cheap multi-model research now makes possible.

    This is part of our OpenRouter coverage. For the operator’s view on why we run model research through OpenRouter, see the field manual. For the structured decision methodology that multi-model setups also enable, see the roundtable methodology.

    The setup

    In mid-May 2026 we ran an autonomous session designed to extract self-knowledge from a wide sample of available LLMs. The question structure was simple: ask each model about its own identity, training, capabilities, and limits, then capture the response for cross-comparison.

    The scope expanded mid-execution from the original 50 to 54 models — the OpenRouter catalog had grown during the session itself, which is its own data point about how fast this ecosystem moves.

    The architecture: a Python script with parallel bash execution, a max-wait timeout per model, graceful per-provider error handling, and Notion publishing of each model’s response as a separate Knowledge Lab entry. Everything billed through OpenRouter.

    The cost: $1.99 against a $270 starting balance. Less than two dollars to canvas 54 frontier and near-frontier models on a question of self-identity.

    The hit rate

    Of 54 models queried, 43 returned substantive responses. One returned a reasoning trace without final content (GPT-5.5 Pro, which we counted as a valid capture given the reasoning content was the interesting part). 10 returned documented failures.

    That’s 81% substantive completion. For a fully autonomous run against a heterogeneous provider pool with no per-model tuning, that’s a meaningful number.

    The 10 failures broke down into clear categories:

    • Rate limiting (429 errors): persistent on a handful of providers. Some had genuine quota issues; some appeared to be hitting upstream limits we couldn’t see from our side.
    • Forbidden (403): providers refusing the request entirely, often for reasons related to account configuration we hadn’t completed.
    • Not found (404): model IDs that had moved or been deprecated between our model-list scrape and the execution.
    • Timeouts: the most interesting category. Grok 4.20 multi-agent consistently exceeded our timeout window — not because it was slow, but because it appears to orchestrate sub-agents that genuinely take more than 40 seconds to produce a final answer. We documented this as a failure for our purposes; for a different use case it would have been a feature.

    The decision we made in real time was not to retry persistent failures. If a provider returned 429 on three consecutive attempts, we let it stand as a documented failure rather than burning the run on retries. The rationale: those providers are either genuinely rate-limited or having an issue, and a fourth attempt in the same minute isn’t going to resolve either.

    The finding that mattered

    Of all the substantive responses, one stood out: aion-2.0 identified itself as Claude.

    Not “trained on Claude data.” Not “fine-tuned from a Claude-derived model.” It described itself, in the first person, as Claude.

    Aion-2.0 is not Claude. It’s a separate model from a separate provider. The most likely explanation is that its training data included a significant volume of Claude outputs, and the model’s self-knowledge inherited Claude’s identity along with Claude’s content patterns. The model learned to be Claude-like in style and, in the process, learned to identify as Claude in substance.

    This is a known phenomenon in the literature on training data contamination, but seeing it surface concretely in a production model — on an answer to a basic self-identity question — is different from reading about it in a paper. It’s a real thing happening at scale, and most users of these models have no idea.

    The implication for anyone running multi-model evaluations: model outputs are not independent. Models trained on the outputs of other models inherit not just style but identity, opinion patterns, and likely failure modes. If you’re running a roundtable methodology and treating three models as three independent perspectives, and one of them is silently downstream of another in training data, your “consensus” might be one model’s perspective dressed in three different costumes.

    This is also an argument for why first-party model selection — choosing models from clearly distinct lineages rather than just “three frontier models” — matters more than people give it credit for.

    The reliability data

    Setting aside the aion-2.0 finding, the bare reliability data from this run is useful on its own terms.

    10 of 54 providers (18.5%) returned errors. That’s a meaningful failure rate for any production workload that depends on cross-model availability. If your application assumes you can call any model in the catalog and get a response, you’re going to be wrong about 1 in 5 of the time on first attempt.

    OpenRouter’s pooled access mitigates this somewhat — for some providers, OpenRouter automatically retries against alternate endpoints when one fails. But the failures we saw were after OpenRouter’s own retry logic ran. These are the failures that surface to the caller after the routing layer has done what it can.

    For production systems, the practical implication is straightforward: never depend on any single model being available. Build fallback chains. Use OpenRouter’s Auto Router with a wildcard allowlist for tolerance, or wire your own fallback logic. A multi-model architecture isn’t a luxury; it’s a reliability requirement.

    The cost shape

    $1.99 of spend across 54 model queries works out to roughly $0.037 per query, including all the failed attempts.

    That’s the headline number, but the distribution matters more than the average. A handful of queries — the ones that hit larger reasoning models like Claude Opus or GPT-5.5 Pro — accounted for the majority of the spend. Cheap models like Gemini Flash and various open-source mid-tier models barely moved the needle.

    If you’re running research at this kind of breadth, the cost model is dominated by the heavy reasoning models, not by the long tail of cheaper models. The implication: when you’re running broad-canvas queries, it costs almost nothing to add another cheap model to the catalog. Adding another expensive reasoning model is what you should be deliberate about.

    What broke and what we learned

    Three patterns of failure repeated:

    Provider rate limits unrelated to our usage. Some providers appear to share upstream capacity with the wider OpenRouter user base, and when that upstream capacity is hot, your individual call fails regardless of your own usage. There is no client-side fix. You either retry later or fall back.

    Model IDs drift. The catalog moves fast. A model ID you fetch on Monday may have been deprecated by Friday. Our script’s freshness window — about a day between model-list scrape and execution — was sometimes enough for drift. For production systems, fetch the model list immediately before the run.

    Multi-agent models exceed simple timeout windows. Grok 4.20’s behavior of orchestrating sub-agents that take 40+ seconds is not a bug; it’s the product. But it breaks any timeout shorter than what the multi-agent run actually needs. If you’re going to call multi-agent models, plan for long latencies and don’t share a timeout policy with single-call models.

    What we’d do differently

    Three changes for the next run of this kind:

    1. Refresh the model list inline. Don’t trust a list scraped even a few hours earlier. Fetch fresh before each batch.
    2. Tiered timeouts. Single-call models on a tight timeout. Multi-agent and reasoning-heavy models on a relaxed one. Detect which is which from the model metadata where possible.
    3. Publish-as-you-go. Our Notion publish step ran after data collection. The session ended mid-publish, leaving uncertainty about which of the 54 pages had actually been created. Better to publish each result immediately as it returns, so a session interruption doesn’t lose anything.

    The bigger lesson

    Two dollars to canvas 54 models on a question of self-identity is a cost structure that didn’t exist three years ago. It also means a category of research that used to require expensive infrastructure is now within reach of anyone with an OpenRouter account and a Python script.

    The interesting finding — aion-2.0 silently identifying as Claude — would have been almost impossible to discover any other way. You can’t catch a training-data identity inheritance by reading model documentation. You catch it by asking a lot of models the same question and looking at the answers side by side.

    OpenRouter, for all its caveats and its limited scope, makes this kind of multi-model research tractable in a way nothing else currently does. If you’re not running periodic broad-canvas queries against your model catalog, you’re flying blind on what’s actually in there. Two dollars is cheap insurance against being surprised by the next aion-2.0.

    Frequently asked questions

    How much does it cost to query 54 LLMs at once via OpenRouter?

    In our autonomous run, the total cost was $1.99 — roughly $0.037 per query including the 10 failed attempts. Cost was dominated by the few queries hitting expensive reasoning models like Claude Opus and GPT-5.5 Pro; the long tail of cheaper models barely moved the needle. Adding more cheap models to a broad-canvas query costs almost nothing.

    What is training-data identity inheritance?

    When a model’s training data includes outputs from another model, the trained model can inherit not just style but identity from the source model. In our run, aion-2.0 identified itself as Claude — likely because its training data contained enough Claude outputs that the model’s self-knowledge absorbed Claude’s identity along with Claude’s content patterns. This is a known phenomenon in the literature on data contamination.

    How reliable are LLM providers via OpenRouter?

    In our 54-model autonomous run, 10 providers (18.5%) returned errors after OpenRouter’s own retry logic ran. The failures broke down into rate limits, forbidden responses, deprecated model IDs, and timeouts on multi-agent models. The practical implication: never depend on any single model being available. Build fallback chains.

    Why did some models timeout in the 54-LLM run?

    The most notable timeout case was Grok 4.20 multi-agent, which appears to orchestrate sub-agents that genuinely take more than 40 seconds to produce a final answer. This isn’t a bug; it’s the product. But it breaks any timeout policy shared with single-call models. Multi-agent and reasoning-heavy models need their own relaxed timeout tier.

    Should I run periodic broad-canvas queries against my model catalog?

    Yes. At roughly two dollars per 54-model run, broad-canvas queries are cheap insurance against being surprised by training-data inheritance, identity drift, or quality degradation in models you depend on. You can’t catch these issues by reading documentation. You catch them by querying widely and comparing answers side by side.

    See also: The 5-Layer OpenRouter Mental Model: Org, Workspace, Guardrail, Key, Preset

  • Claude Code Case Studies: What the Numbers Actually Say in 2026

    Claude Code Case Studies: What the Numbers Actually Say in 2026

    Most “Claude Code changed my life” posts are vibes. The interesting case studies are the ones with a number attached — a PR count, a token spend, a defect rate, a codebase size. After spending the week reading every concrete writeup I could find and cross-referencing them against Anthropic’s own internal usage report, three patterns hold up. Everything else is marketing.

    Here is what the credible Claude Code case studies actually say, what they share in common, and where the wheels come off when teams try to repeat them.

    Case 1: The 350k-line solo codebase

    The most cited solo-developer case study right now is a maintainer of a 350,000+ line codebase spanning PHP, TypeScript/React, React Native, Terraform, and Python. Since August 2025, 80%+ of all code changes in that codebase have been written by Claude Code — generated, then corrected by Claude Code after review, with only minimal manual refactoring. The author has been working in commercial software for 10+ years, so this is not a beginner overstating things.

    The two operational constraints they call out are the ones that matter:

    • Context selection is the job. A 200k token context window is less than 5% of a codebase this size. Include the files that show your patterns, exclude anything irrelevant, and accept that “too much context” degrades output as badly as “too little.”
    • Speed parity is the gate. If an LLM implementation isn’t at least as fast as doing it yourself, you’ve added a tool and lost time. They keep working documents to 50–100 lines and start every task with the bare minimum context.

    This is the case study to send to anyone asking “does Claude Code work on legacy code.” The answer is yes, but only after you treat context curation as a first-class engineering activity.

    Case 2: Anthropic’s own internal teams

    Anthropic published a usage report covering ten internal teams. It is the highest-signal document in the ecosystem because every example is from a team that has unlimited access and zero incentive to oversell it. The patterns worth stealing:

    • Data Infrastructure lets Claude Code use OCR to read error screenshots, diagnose Kubernetes IP exhaustion, and emit fix commands. The team is not writing prompts about Kubernetes — they’re handing Claude a screenshot and a goal.
    • Growth Marketing built an agentic workflow that processes CSVs of hundreds of existing ads with performance metrics, identifies underperformers, and uses two specialized sub-agents to generate replacement variations under strict character limits. Sub-agents matter here — a single agent loses the constraint discipline.
    • Legal built a prototype “phone tree” to route team members to the right Anthropic lawyer. Non-engineering team, real internal tool, shipped.
    • Finance staff describe requirements in natural language; Claude Code generates the query and outputs Excel. No SQL skill required from the requester.

    The Claude Code product team itself uses auto-accept mode for rapid prototyping but explicitly limits that pattern to the product’s edges, not core business logic. The RL Engineering team reports auto-accept succeeds on the first attempt about one-third of the time. That’s the honest number to hold onto when someone tells you their agent “just works.”

    Case 3: The Sanity staff engineer’s six-week journey

    The single most useful sentence in any Claude Code case study this year came from a staff engineer’s six-week writeup at Sanity: “First attempt will be 95% garbage.” That’s not a complaint — it’s an operating manual. The engineer’s workflow runs three or four parallel agents, treats every first pass as a draft to be re-prompted, and reserves human attention for architecture and steering rather than typing.

    This is also the case study that matches the Pragmatic Engineer’s February 2026 survey of 15,000 developers, which ranked Claude Code as the most-used AI coding tool on the market. The teams who report the biggest gains are not the ones treating it like autocomplete. They’re the ones running multiple threads, accepting that most first drafts are throwaway, and putting their senior judgment on review rather than authorship.

    What every credible case study has in common

    Cross-reference the three above with the dozen other writeups that include real numbers and the same five operational habits show up every time:

    • A written context doc. Every successful team has something Claude reads first — a CLAUDE.md, a .clauderules file, a project README that defines patterns and conventions. Teams without one get inconsistent output.
    • Sub-agents for constraints. One agent that has to remember the character limit, the style guide, the schema, and the deadline will drop one of them. Two agents — generator and constraint-checker — won’t.
    • Real review on the way in. The 80% figure from the 350k-LOC case includes “corrected by Claude Code after review.” Nobody is shipping unreviewed agent output to production and reporting wins.
    • A measurement loop. Faros and Jellyfish reports both show teams using Claude Code analytics to track PRs and lines shipped with AI assist. The teams that measure ship more; the teams that don’t, drift.
    • Honest scoping. Auto-accept on edges, synchronous prompting on core business logic. Every team that ignores this distinction generates the “tech debt nightmare” posts.

    Where the case studies break down

    Two warnings from the data. First, Jellyfish’s AI Engineering Trends report shows a 4.5x increase in companies running agentic coding workflows, but most engineering teams using these tools spend $200–$600 per engineer per month and report a 1.6x productivity multiplier — not the 10x that vendor marketing implies. The case studies you read are the wins; the median outcome is more modest.

    Second, the model version you run matters more than any workflow trick. As of this week the flagship is claude-opus-4-7, the workhorse is claude-sonnet-4-6, and the fast option is claude-haiku-4-5-20251001. Opus 4.7 lifted resolution on a 93-task coding benchmark by 13% over Opus 4.6 — including four tasks that neither Opus 4.6 nor Sonnet 4.6 could solve. Teams running on stale model strings are leaving real capability on the table.

    The takeaway

    If you only steal one thing from the credible case studies, steal the context discipline. The 350k-LOC maintainer keeps documents to 50–100 lines. Anthropic’s own teams use sub-agents to enforce constraints. The Sanity engineer runs parallel agents and treats first drafts as garbage by default. None of these patterns require a special prompt or a hidden flag. They require deciding, before you start a task, what Claude is allowed to see and what it isn’t.

    That’s the whole game. The teams shipping 80% of their code with Claude Code aren’t using a better model — they’re feeding it a better context.

  • Claude at Scale: Every Usage Limit, Context Window, and File Size Cap (May 2026)

    Claude at Scale: Every Usage Limit, Context Window, and File Size Cap (May 2026)

    Last refreshed: May 15, 2026

    Claude usage limits at scale - context window, file size, team seats, extra usage
    Once you stop asking what Claude is and start asking how to use it at scale, the limits become the conversation.

    Once you stop asking “what is Claude” and start asking “how do I use Claude at scale,” you run into a different category of question. How big is the context window, actually, in this specific situation? What’s the file upload limit? What happens when one teammate burns through the Team plan? Where does the 1M context window apply and where doesn’t it? When does extra usage kick in and what does it cost?

    The answers exist — they’re just spread across a dozen Anthropic Help Center articles, and the wrong combination of guesses can make you think you’ve hit a hard limit when you’ve actually just hit the wrong setting. This article is the consolidated map. Triple-sourced against Anthropic’s official documentation, verified May 15, 2026.

    The four limits that matter most

    If you’re running Claude in any sustained capacity, four limits will define your experience. Get these right and you have headroom. Get them wrong and you’ll think Claude is broken when it’s actually working as designed.

    1. Context window — how much Claude can read in a single conversation. Varies by model and surface. The 1M window is real but only available in specific places.

    2. File upload size — how big a single file can be. 30 MB cap per file across the board, with workarounds for larger files.

    3. Usage limits — how much Claude work you can do per session/week. Per-user, not pooled. Different limits for chat vs Claude Code vs Agent SDK.

    4. Extra usage / overage — what happens when you hit the cap. Either you’ve enabled it and you keep going at API rates, or you’re stopped until the limit resets.

    Context window: where 1M tokens actually applies

    Per Anthropic’s Help Center documentation (verified May 15, 2026), context window size depends on the model AND on the surface you’re using Claude through. This is the single most-misunderstood limit because the same model can have a different context window in chat than it does in Claude Code or the API.

    Web and desktop chat (claude.ai):

    • Opus 4.7, Opus 4.6, Sonnet 4.6 — 500K tokens on all paid plans
    • All other models — 200K tokens on paid plans

    Claude Code:

    • Opus 4.7 — 1M tokens on Pro, Max, Team, and Enterprise
    • Sonnet 4.6 — 1M tokens on all paid plans, but extra usage must be enabled to access it (except on usage-based Enterprise plans)

    Claude API:

    • Opus 4.7, Opus 4.6, Sonnet 4.6 — 1M tokens at standard pricing (no long-context premium)
    • All other models — 200K tokens

    The practical translation: if you need the full 1M token window, use Claude Code or the API with one of the supported models. The web chat tops out at 500K even on the most capable models. That difference matters when you’re trying to feed Claude an entire codebase, a long video transcript, or a multi-document research bundle.

    File upload size: 30 MB per file, with workarounds

    Per Anthropic’s Help Center, the maximum file size for both uploads and downloads is 30 MB per file. This applies whether you’re uploading a PDF, a CSV, an image, or any other supported file type.

    For PDFs larger than 30 MB, Anthropic’s documentation notes that Claude can process them through its computing environment without loading them into the context window. That’s a real workaround for big PDFs but it doesn’t help you for other large file types.

    If you regularly hit the 30 MB cap, the practical patterns are:

    • Split before upload — break the file into chunks under 30 MB, upload each, work with them as separate sources
    • Convert format — a 35 MB Word doc with embedded images may compress to under 30 MB as a PDF; CSVs can often be reduced by removing unused columns
    • Upload to GCS or S3 and let Claude read via tools — for the Agent SDK / API path, you can put the file in cloud storage and have Claude read it via web fetch or a custom tool, bypassing the upload cap entirely

    Usage limits: per-user, not pooled

    This is the limit that confuses teams the most. Per Anthropic’s Help Center documentation on the Team plan (verified May 15, 2026): each team member has their own set of usage limits. They are not shared across the team.

    If one teammate burns through their session limit, the rest of the team is unaffected. There is no pooled team allowance that one user can drain on behalf of others. The math is per-seat, always.

    The usage limits themselves vary by seat type:

    • Standard Team seats — 1.25x more usage per session than Pro plan. One weekly usage limit applies across all models. Resets seven days after the session starts.
    • Premium Team seats — 6.25x more usage per session than Pro plan. Two weekly limits: one across all models, plus a separate one for Sonnet models specifically. Both reset seven days after session start.

    For the actual numeric token-per-session limits, Anthropic does not publish exact numbers — they describe relative multipliers vs Pro. This is intentional; the underlying math is calibrated against typical workloads rather than a hard token ceiling.

    Extra usage: what happens when you hit the cap

    When a user hits their weekly limit, two things can happen depending on whether the organization has enabled extra usage:

    If extra usage is enabled: additional Claude requests continue to flow at standard API rates (the same per-token pricing published on Anthropic’s pricing docs — $5/$25 MTok for Opus 4.7, $3/$15 for Sonnet 4.6, $1/$5 for Haiku 4.5). Extra usage is billed separately from the subscription. Team and Enterprise admins can enable, cap, and monitor extra usage at the organization level.

    If extra usage is not enabled: the user’s Claude requests stop until their limit resets at the start of the next session window (seven days from when the current session started, not a fixed weekly day).

    The right setting depends on your team’s tolerance for surprise bills versus interrupted workflows. Most production teams enable extra usage with a hard organizational cap so individual users have continuity but the org has predictable spend ceiling.

    Claude Code limits: a separate model

    Claude Code has its own usage limit accounting that exists alongside chat usage limits. Per Anthropic’s Help Center on Claude Code models, usage, and limits (verified May 15, 2026):

    • Interactive Claude Code (typing in terminal/IDE) draws from your subscription’s usage limits, the same pool as web chat
    • Non-interactive claude -p mode currently also draws from subscription usage limits — until June 15, 2026
    • Starting June 15, 2026, non-interactive mode and Agent SDK usage move to a separate per-user monthly Agent SDK credit pool

    The June 15 change is important enough that it gets its own breakdown in our Agent SDK Dual-Bucket Billing article. The short version: if you’re running unattended Claude Code work in cron jobs or CI, your billing model is changing. Plan capacity against the new credit pool.

    The limits that aren’t really limits

    Three things that get reported as limits but are actually configuration choices:

    “My context window keeps filling up.” This is usually caused by long-running conversations accumulating history rather than the model’s actual context window being too small. Starting a new conversation (or running /clear in Claude Code) resets the working context. Long sessions are not a hard limit; they are a working-memory pressure that compounds over turns.

    “Claude won’t read my whole repository.” Repository size is rarely the actual limit; the limit is how much you can load into the context window at once. Tools like Claude Code’s file reading and search work around this by loading files on demand rather than upfront. The 1M context window helps but is not a substitute for selective loading.

    “My team keeps hitting limits even though we’re on Team.” Almost always one of two things: (a) people are mistakenly assuming the seat allowance is shared, when it’s strictly per-user; (b) someone is running heavy automation through a subscription seat instead of a Claude Developer Platform API key (which is the recommended path for sustained team-wide automation, especially after June 15).

    Decision matrix: which limits affect which use case

    Map your use case to the limits that actually apply:

    • Solo chat user on Pro — 500K context on Opus 4.7/4.6/Sonnet 4.6 in chat, weekly session limit, 30 MB upload cap. Hit your limit and you wait or pay extra usage.
    • Solo developer using Claude Code — 1M context on Opus 4.7 (1M on Sonnet 4.6 with extra usage on). Same weekly session limit. June 15 billing change applies if you use claude -p.
    • Small team on Team Standard — Per-seat limits at 1.25x Pro session capacity, not pooled. 30 MB upload cap. June 15 billing change applies per-seat.
    • Team running Claude Code in CI — All of the above plus separate Agent SDK credit pool starting June 15. Strongly consider a Developer Platform API key for the CI workload to get true pay-as-you-go billing.
    • Enterprise running large-scale automation — Subscription limits are the wrong tool. Move to a Developer Platform API key, monitor usage at the org level, set spend caps in the Console.

    What to actually do this week

    1. Identify which surface you’re using Claude through (web, Claude Code, API). Different surfaces have different context windows even for the same model.
    2. If you’re hitting “limit” errors, check whether extra usage is enabled at the organization level before assuming it’s a hard cap.
    3. If you’re a Team admin and your team is reporting hitting limits, audit per-seat usage rather than assuming you need to upgrade the plan — the issue is often one heavy user, not the plan tier.
    4. If anyone on your team is running unattended Claude work, read the Agent SDK billing change before June 15.
    5. If you need the full 1M context window, switch to Claude Code or the API. Web chat tops out at 500K.
    6. For uploads larger than 30 MB, split, compress, or move the file to cloud storage and have Claude read it via tools.

    Frequently Asked Questions

    Is the Claude Team plan usage limit shared across team members?

    No. Per Anthropic’s Help Center documentation, each team member has their own set of usage limits. If one team member reaches their seat’s included limit, other team members are unaffected and can keep working.

    What is Claude’s file upload size limit?

    30 MB per file for both uploads and downloads, per Anthropic’s official documentation. For PDFs larger than 30 MB, Claude can process them through its computing environment without loading them into the context window.

    Where does the 1M token context window actually apply?

    1M context is available on Claude Code with Opus 4.7 (Pro/Max/Team/Enterprise) and on the API with Opus 4.7, Opus 4.6, and Sonnet 4.6. Web chat tops out at 500K tokens even on the most capable models. Sonnet 4.6 in Claude Code requires extra usage to be enabled to access the 1M window (except on usage-based Enterprise plans).

    What’s the difference between Standard and Premium Team seats?

    Standard seats offer 1.25x Pro plan usage per session with one weekly limit across all models. Premium seats offer 6.25x Pro session usage with two weekly limits (one across all models, one Sonnet-specific). Both reset seven days after the session starts.

    What happens when I hit my Claude usage limit?

    If extra usage is enabled at your organization, you continue at standard API rates billed separately. If extra usage is not enabled, your requests stop until your limit resets at the next session window (seven days from session start, not a fixed weekly day).

    Should I use a Team plan or the API for production automation?

    For sustained shared automation (CI pipelines, cron jobs, background services), Anthropic recommends the Claude Developer Platform with an API key over subscription seats. Subscription seats are sized for individual interactive use; API keys give you predictable pay-as-you-go billing, no per-seat caps, and don’t compete with team members’ interactive usage.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Anthropic Help Center: Understanding usage and length limits, What is the Team plan?, How is my Team plan bill calculated?, Manage extra usage for Team and seat-based Enterprise plans, Models, usage, and limits in Claude Code, How large is the context window on paid Claude plans?, How large is the Claude API’s context window?, Upload files to Claude (primary sources for all limit specifics)
    • Anthropic platform documentation: Context windows at docs.claude.com (primary source for API context window behavior)
    • Anthropic Help Center: Use the Claude Agent SDK with your Claude plan (primary source for the June 15, 2026 billing change)

    All limit numbers and policies are accurate as of May 15, 2026. Anthropic adjusts subscription mechanics regularly; if you’re making procurement decisions on this article more than 60 days from the date stamp, re-verify the per-seat multipliers and context window availability against the current Help Center.

  • How to Install and Deploy Claude Code in Production: The Complete Team Guide (May 2026)

    How to Install and Deploy Claude Code in Production: The Complete Team Guide (May 2026)

    Last refreshed: May 15, 2026

    Claude Code production deployment - install paths, CI integration, and team-scale cost controls
    Installing Claude Code is the easy part. Deploying it across a team in production is the part most guides skip.

    Most of the published guidance on installing Claude Code stops at “run npm install -g and you’re done.” That’s enough for a developer playing on a laptop. It is not enough for a team that wants to run Claude Code in production — in CI, in shared infrastructure, behind a firewall, with cost controls, and with the new Agent SDK billing model that takes effect June 15, 2026.

    This article is the production deployment guide. Triple-sourced against Anthropic’s own Claude Code documentation, the github.com/anthropics/claude-code-action repo, and Anthropic’s announced June 15 billing model. Verified May 15, 2026.

    The three install paths and which to pick

    Per Anthropic’s official Claude Code docs, there are three supported ways to install Claude Code. They produce the same underlying binary but make sense in different operational contexts.

    1. Standalone installer. A native installer for macOS, Windows, and Linux that drops the Claude Code binary in a system path. This is the cleanest install for individual developers — no Node.js required, no npm dependency, predictable upgrade behavior. Use this on workstations where the operator owns the machine.

    2. npm global package. npm install -g @anthropic-ai/claude-code. Requires Node.js 18 or later. Pulls the same native binary as the standalone installer through a per-platform optional dependency, then a postinstall step links it into place. Use this when you already manage developer tools through npm and want one less install path to track. Supported platforms: darwin-arm64, darwin-x64, linux-x64, linux-arm64, linux-x64-musl, linux-arm64-musl, win32-x64, win32-arm64.

    3. Desktop app. A desktop-class application distributed via .dmg on macOS and MSIX/.exe on Windows. This is the path most teams will deploy to non-developer staff, and it integrates with enterprise device management tools like Jamf, Kandji, and standard Windows MSIX deployment.

    If you are deploying across a team larger than a handful of developers, mix-and-match: standalone or npm for engineering workstations, desktop for everyone else.

    The npm install gotchas worth knowing before you ship

    Two things in Anthropic’s official docs are worth flagging because they will save you from a whole class of bug reports later:

    Don’t use sudo. Anthropic’s setup documentation explicitly warns against sudo npm install -g @anthropic-ai/claude-code. It can lead to permission issues and security risks. If you need a global install on a machine where your user can’t write to the npm prefix, fix the npm prefix first (point it at a user-writable directory) rather than escalating with sudo.

    Don’t use npm update for upgrades. The right command per Anthropic’s docs is npm install -g @anthropic-ai/claude-code@latest. npm update -g respects the original semver range and may not move you to the newest release. This trips up CI pipelines that try to keep Claude Code current via update; they will sit on a stale version forever.

    Production deployment considerations

    The single most important piece of context for a production Claude Code deployment in 2026: the billing model changes on June 15, 2026.

    Before June 15, Claude Code interactive sessions and claude -p non-interactive runs both draw from your normal subscription usage limits. Starting June 15, interactive Claude Code keeps using subscription limits as before, but claude -p and direct Agent SDK usage move to a separate per-user monthly Agent SDK credit pool ($20 Pro, $100 Max 5x, $200 Max 20x, $20-$100 Team, up to $200 Enterprise).

    For teams running Claude Code in CI, in cron jobs, in shell scripts, in GitHub Actions workflows — anywhere the trigger is automated rather than a human — this changes the economics. Plan capacity against the new credit pool, not the legacy shared subscription pool. Full breakdown in our Agent SDK Dual-Bucket Billing article.

    Three other production considerations:

    Network configuration. Behind a corporate firewall, you’ll need to allowlist Anthropic’s API endpoints, configure proxy settings, and potentially route through an LLM gateway. Anthropic’s network configuration documentation covers the specifics.

    Enterprise device deployment. Per Anthropic’s official docs, the desktop app distributes through standard enterprise tools — Jamf and Kandji on macOS via the .dmg installer, MSIX or .exe on Windows. If your IT team already has a deployment workflow for similar developer tools, Claude Code drops into it without anything special.

    API key management. If your team uses Claude Developer Platform API keys instead of (or alongside) subscription auth, manage them like any other production secret — vault them, rotate them, scope them per environment, never check them into source control. This becomes more important after June 15 because API key usage is the recommended path for sustained shared automation, and unintended sprawl gets expensive.

    Claude Code GitHub Actions: the team multiplier

    The fastest way to get team-level value from Claude Code is the official GitHub Actions integration. From Anthropic’s documentation and the public github.com/anthropics/claude-code-action repository:

    The setup command. The cleanest install is to run /install-github-app from inside Claude Code in your terminal. It walks you through installing the GitHub App, configuring the required secrets, and wiring the workflow file. Manual setup also works — copy the workflow YAML from Anthropic’s docs and add the ANTHROPIC_API_KEY secret to your repository settings — but the install command saves the assembly time.

    The interaction model. Once installed, mentioning @claude in a pull request comment or an issue triggers Claude Code to act on the context. Claude can analyze the diff, create new PRs, implement features described in an issue, fix reported bugs, and respond to follow-up comments — all while adhering to whatever conventions you’ve documented in your repository’s CLAUDE.md file.

    Three use cases worth separating clearly.

    • Automated code review. Claude Code reads the diff on every pull request and posts inline comments flagging potential issues, suggesting improvements, or checking for convention violations. Highest signal-to-noise when path-filtered to relevant code only.
    • Issue-to-PR automation. Tag @claude on a well-described issue and Claude Code opens a PR implementing it. Best for small, well-scoped changes; less useful for architectural work.
    • On-demand assistance. Reviewers tag @claude mid-PR to ask questions, request explanations, or get a second opinion before merging. The most defensible use case because it keeps a human in the decision loop.

    Pick the use case that matches your team’s actual bottleneck. Running all three at once on every PR is the fastest way to burn through your usage budget without proportionate value.

    Cost expectations at team scale

    Independent reports as of May 2026 put Claude Code GitHub Actions PR-review costs at roughly $15-25 per month for a team of 3-5 developers doing 10-15 PRs per week, billed against a Claude Developer Platform API key at Sonnet rates. That figure should be treated as directional — your actual cost depends on PR size, how many tools you’ve configured, model selection, and how aggressive your path-filtering is.

    Two cost controls that materially change the math:

    • Path filters. Trigger Claude Code only on file changes that actually need review. Skipping documentation, generated files, and lockfile-only PRs cuts the bill substantially.
    • Concurrency limits. GitHub Actions concurrency settings prevent Claude Code from running multiple instances against the same branch at once. Without this, force-pushes and rapid-fire updates can stack runs.

    If you are running Claude Code on every PR across an active team, you will hit Anthropic API rate limits. The mitigation is path filters, concurrency limits, and batching — none of which are speculative; they are documented patterns.

    The CLAUDE.md file is not optional

    Whatever your install path and whatever your use case, the single piece of project context that has the largest effect on Claude Code’s output is the CLAUDE.md file at the root of your repository. This is where you tell Claude Code what your project is, what conventions to follow, what tools are available, what to avoid, and what success looks like.

    If you skip it, Claude Code is reasoning from the files alone — useful but generic. If you write it, Claude Code is reasoning with your team’s context and your specific codebase rules. The difference shows up in the first ten minutes of use.

    A practical CLAUDE.md for a production team usually includes: the project’s purpose and stack, naming conventions and folder structure, testing requirements, lint and format rules, deployment considerations, what kinds of changes need human review, and explicit prohibitions (“never commit migrations directly to main”, “always update X when you change Y”). Keep it concise — verbose CLAUDE.md files inflate every per-turn token cost across the team.

    What to actually do this week

    1. Pick your install path per role (standalone or npm for developers, desktop for everyone else).
    2. Install Claude Code on one workstation and run through the quickstart end-to-end before rolling to the team.
    3. Write a real CLAUDE.md for your primary repository before anyone uses Claude Code on it. Even a 100-line version is far better than nothing.
    4. If you’re running anything automated, read the Agent SDK billing change before June 15.
    5. If you want team-level value, install the GitHub Actions integration — but pick one use case (code review, issue-to-PR, or on-demand help), not all three at once.
    6. Set path filters and concurrency limits in your workflow before you put Claude Code on every PR.

    Frequently Asked Questions

    What’s the difference between the npm install and the standalone installer?

    None functionally — both install the same native binary. The npm path is convenient if you already manage developer tools through npm. The standalone installer is cleaner if you don’t want a Node.js dependency. Both upgrade through their own mechanism.

    Why does Anthropic say not to use sudo with npm install?

    Per Anthropic’s official setup documentation, sudo with global npm installs can create permission issues and security risks. The recommended fix is to configure your npm prefix to a user-writable directory, then install without elevated privileges.

    How do I upgrade Claude Code installed via npm?

    Run npm install -g @anthropic-ai/claude-code@latest. Don’t use npm update -g — it respects the original semver range and may not move you to the latest release. This is documented in Anthropic’s setup guide.

    Does Claude Code work in CI/CD pipelines?

    Yes. The official GitHub Actions integration is the recommended path for GitHub-based workflows. For other CI systems (GitLab, CircleCI, Jenkins), the underlying tool is the Claude Agent SDK plus claude -p. Both move to the new Agent SDK monthly credit pool on June 15, 2026.

    How much does Claude Code GitHub Actions cost for a team?

    Independent reports as of May 2026 estimate $15-25/month for a 3-5 developer team running PR review on 10-15 PRs/week at Sonnet rates with a Claude Developer Platform API key. Actual cost varies with PR size, tool configuration, model selection, and path filtering aggressiveness.

    What’s the single biggest mistake teams make installing Claude Code?

    Skipping the CLAUDE.md file. Without it, Claude Code reasons generically against your codebase. With even a basic CLAUDE.md describing your conventions and constraints, output quality improves substantially across every interaction. It is the highest-leverage 30-minute setup task.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Anthropic Claude Code documentation: Set up Claude Code and Advanced setup at code.claude.com (primary source for install paths, npm gotchas, enterprise deployment patterns)
    • Anthropic Claude Code GitHub Actions documentation at code.claude.com/docs/en/github-actions (primary source for the GitHub Actions integration setup and use cases)
    • github.com/anthropics/claude-code-action public repository (primary source for the action’s interaction model)
    • Anthropic Help Center: Use the Claude Agent SDK with your Claude plan (primary source for the June 15, 2026 billing change)
    • Independent cost analyses (KissAPI, OpenHelm, Steve Kinney) for the team-scale cost estimates — Tier 2 confirming sources

    Cost figures and version specifics in this article are accurate as of May 15, 2026. Anthropic ships Claude Code updates frequently; the install paths and CLI commands are stable, but pricing and rate limits are the most likely figures to need re-verification.

  • Notion Developer Platform Launch (May 13, 2026): What Changes for Claude Users and the Three-Legged Stack

    Notion Developer Platform Launch (May 13, 2026): What Changes for Claude Users and the Three-Legged Stack

    Last refreshed: May 15, 2026

    The Three-Legged Stack: Claude, Notion, GCP - walnut stool with copper, porcelain, and steel legs representing the Tygart Media AI operating stack
    Notion’s May 13 Developer Platform launch reshapes how the Notion + Claude + GCP stack fits together.

    On May 13, 2026, Notion shipped what is, structurally, the biggest change to how Notion fits into an AI-driven operating stack since the original Notion AI launch. Version 3.5 — the Notion Developer Platform — turns Notion from a workspace that you operate into a platform that other agents can operate inside. Claude is one of the launch partners.

    This article is written from inside the practice of running a business on a three-legged stool of Notion, Claude, and Google Cloud. The Developer Platform launch matters to that stool in specific ways, and most of the day-one coverage is missing them. The goal here is to pin down what shipped, what it actually changes for an operator who already runs Claude against Notion, and where the seams are between this platform and the way most of us were already wiring things together.

    What Notion actually shipped on May 13, 2026

    From Notion’s own release notes for version 3.5 (verified May 15, 2026), the Developer Platform comprises four meaningfully distinct pieces:

    Workers. A cloud-based runtime that runs custom code inside Notion’s infrastructure. Workers is how you take a Notion-resident workflow and bind real compute to it — running on a schedule, reacting to a database trigger, fanning work out to other systems — without standing up your own infrastructure for the runtime.

    Database sync. Notion databases can now pull live data from any API-enabled external source. The thing that used to require a Zapier or Make.com bridge becomes a property of the database itself.

    External Agents API. The piece that matters most for Claude users: an outside AI agent can appear and operate inside the Notion workspace as a first-class collaborator. Claude is one of the launch partners, alongside Cursor, Codex, and Decagon.

    Notion CLI. A command-line tool through which both developers and agents interact with the platform. Available across all plan tiers.

    The packaging detail worth noting: Workers and the Developer Platform deployment surface are limited to Business and Enterprise plans, but the External Agents API and the CLI are available on all tiers. The whole platform is free to use through August 11, 2026.

    The shift in framing, in operator terms

    Before May 13, the standard pattern for getting Claude to work with Notion looked like this: install a Notion MCP server, point Claude Code at it, and use Claude as the active driver that reads from and writes to Notion through tool calls. Notion was the database, Claude was the agent, MCP was the wire.

    After May 13, the relationship can flip. The External Agents API lets Claude appear inside Notion — not as an external tool you switch to, but as a collaborator your team can assign work to from the same task board where you assign work to humans. The wire is no longer “Claude reaches into Notion when called.” It’s “Notion can hand work to Claude the same way it can hand work to a person.”

    For an operator running a second-brain architecture, that’s a meaningful change. It moves Claude from a tool you invoke into a participant your system operates against. Both modes are still available — MCP wiring still works fine — but the External Agents API opens a different set of patterns where the system of record stays in Notion and Claude becomes one of several agents that the system orchestrates.

    Where this fits in the three-legged stool

    For anyone running Notion + Claude + Google Cloud as the operating stack of a small business or solo operator setup, the Developer Platform launch reinforces something the architecture was already pointing at: Notion is the system of record, Claude is the reasoning layer, GCP is the compute and data substrate. The May 13 launch makes that division of labor more legible.

    • Notion as system of record — Workers and database sync make Notion an active control plane, not just a passive document store. State lives here. Workflows initiate here.
    • Claude as reasoning layer — The External Agents API gives Claude a formal role inside Notion’s task management, planning, and review loops. Claude does the thinking; Notion holds the result.
    • GCP as compute substrate — Anything Workers can’t do (long-running automation, heavy compute, custom data pipelines, things that need to live behind a firewall), Cloud Run and Compute Engine still handle. Workers doesn’t replace GCP for the operations that need real horsepower; it extends Notion into the lightweight automation gap that previously required a Zapier-class bridge.

    The leg that grows the most from this launch is Notion. It picks up native automation and native AI-agent orchestration in one shipment. The leg that doesn’t change is Google Cloud — GCP is still where the heavyweight workloads live, the per-site WordPress fortresses run, and the custom Python and Node services that hold the operational glue together.

    The Claude-specific implications

    Anthropic’s customer page on Notion (verified May 15, 2026) confirms that Notion has integrated Claude Managed Agents — the version of Claude designed for long-running sessions with persistent memory and high-quality multi-turn outputs. Notion has also made Claude Opus available inside Notion Agent for the first time as part of the broader integration. The framing from Anthropic’s side: Notion is a design partner that helped shape Claude Code’s early development, and the External Agents API is the formal extension of that partnership into the Notion product surface.

    Practically, three things change for someone who already runs Claude against Notion:

    1. The MCP wiring is no longer the only path. If you’ve been using a Notion MCP server to give Claude Code read-write access to your workspace, that pattern still works and still has its place — particularly for developer workflows where Claude is doing the driving. But for operational workflows where Notion should drive and Claude should respond, the External Agents API is now the more natural fit.

    2. Multi-agent orchestration becomes a first-class concept. When Notion can address Claude, Cursor, Codex, and Decagon as discrete agents, the question stops being “which AI tool do I use” and becomes “which agent gets which task.” That’s a richer surface for actually distributing work across capabilities — Cursor for IDE-bound coding, Claude for long-form reasoning and writing, Decagon for customer-facing workflows. The orchestration sits in Notion.

    3. The persistent-memory pattern gets cleaner. The “Notion as Claude’s memory” architecture that we and others have been building with MCP wiring is now a supported, native pattern rather than a clever workaround. The structured pages, databases, and templates that hold what Claude needs to remember between sessions can now be addressed through a sanctioned API rather than reverse-engineered through tool calls.

    What we’d actually rebuild now

    If we were starting our second-brain architecture from scratch on May 15, 2026, knowing what shipped on May 13, the build order would be different than what we have today:

    • Database structures stay in Notion — same as before. The systems of record (clients, projects, content pipelines, scheduled tasks, the Promotion Ledger) all live in Notion databases.
    • Sync replaces a meaningful chunk of Zapier/Make — anywhere we currently bridge Notion to an external API for read or for write, native database sync becomes the first thing to try before reaching for a third-party automation tool.
    • Workers handles light recurring automation — the kind of thing we currently run as a Cloud Run cron job, where the trigger and state both live in Notion. Workers is closer to the data and easier to reason about for operators who don’t want to context-switch out of Notion.
    • External Agents API for Claude orchestration — Claude assignments come from inside Notion’s task surfaces. The Promotion Ledger, the editorial calendar, the client deliverable boards all become places where Claude can be assigned the same way a teammate is assigned.
    • GCP holds everything that’s heavyweight or sensitive — WordPress fortresses, custom data pipelines, anything HIPAA/regulated, the AI Media Architect run on Cloud Run, the knowledge-cluster-vm. None of this moves. Notion’s platform doesn’t compete here.

    The honest part: most of our existing infrastructure is staying. The Developer Platform launch isn’t a “rebuild everything” moment. It’s a “reach for Notion-native first when the workflow naturally lives in Notion anyway” moment. Where we used to glue together MCP servers, Zapier flows, and custom Cloud Run jobs to bridge gaps, the gaps are smaller now.

    The seams worth noticing

    Three things to be honest about:

    Workers is plan-gated. If you’re on a Notion plan below Business, you can use the External Agents API and the CLI but not Workers. The full programmable-platform vision requires the upgrade. For solo operators on Plus or below, this is a real friction point.

    The free-through-August window is a usage signal, not a permanent state. The Developer Platform is free through August 11, 2026. Notion has not yet published post-window pricing. Anyone building production workloads against the platform should plan for the possibility of a usage-based or tier-gated pricing model after that date.

    External Agents is a launch-partner-first model. Claude Code, Cursor, Codex, and Decagon are first-class. Other agents — and there will be other agents — show up later through the API. If your stack depends on an agent that isn’t on the launch partner list, the surface for integrating it is smaller right now than it will be in a few months.

    What to actually do this week

    If you’re running Claude against Notion in any operational capacity:

    1. Read Notion’s official release notes for 3.5 (notion.com/releases/2026-05-13). It’s short and concrete.
    2. Try the Notion CLI on a non-production workspace. The CLI is the lowest-friction way to feel what’s actually changed.
    3. If you have any workflow currently glued together with Zapier/Make where the trigger and state are both in Notion, evaluate whether database sync or Workers replaces it more cleanly.
    4. If you currently invoke Claude through MCP for tasks that would more naturally be assigned to Claude from inside Notion’s task boards, prototype the same workflow through the External Agents API and compare.
    5. Don’t migrate anything you don’t have to. The May 13 launch creates new options, not new mandates.

    Frequently Asked Questions

    What is the Notion Developer Platform?

    It’s the May 13, 2026 release (Notion 3.5) that adds Workers (cloud-based runtime), database sync (live data from external APIs), an External Agents API (outside AI agents operating natively inside Notion), and a Notion CLI. It turns Notion from an application you use into a platform you and your agents can build on.

    Is Claude one of the launch partners?

    Yes. Per Notion’s release notes and Anthropic’s customer page on Notion (both verified May 15, 2026), Claude is a launch partner alongside Cursor, Codex, and Decagon. Notion has also integrated Claude Managed Agents and made Claude Opus available inside Notion Agent.

    How is the External Agents API different from connecting Claude through MCP?

    MCP wiring lets Claude reach into Notion through tool calls — Claude is the driver, Notion is the data source. The External Agents API lets Claude appear inside Notion as a collaborator that can be assigned work — Notion is the driver, Claude is one of several agents responding. Both patterns coexist. Pick the one that matches who should be in charge of the workflow.

    What does the Developer Platform cost?

    Free through August 11, 2026, per Notion’s release notes. Workers and the deploy surface are limited to Business and Enterprise plans; the External Agents API and CLI are available across all tiers. Post-window pricing has not been published as of May 15, 2026.

    Does this replace MCP servers?

    No. MCP servers remain useful — particularly for developer workflows where Claude is doing the driving from inside Claude Code, and for cases where you need Claude to talk to multiple systems (not just Notion). The External Agents API adds an alternative pattern for the cases where Notion should hold the workflow and Claude should respond to it.

    Should I move workloads off Google Cloud onto Notion Workers?

    For most things, no. Workers is suited to lightweight, Notion-native automation. Heavy compute, regulated workloads, custom data pipelines, and anything that needs to live behind a firewall still belong on GCP (or your equivalent cloud). The Developer Platform extends what Notion can do natively; it doesn’t replace what cloud infrastructure does.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Notion official release notes: May 13, 2026 – 3.5: Notion Developer Platform at notion.com/releases/2026-05-13 (primary source for what shipped, pricing window, plan-tier gating)
    • Anthropic customer page on Notion at claude.com/customers/notion (primary source for Claude Managed Agents integration, Opus availability in Notion Agent, design-partner relationship)
    • TechCrunch coverage of the May 13 launch (Tier 2 confirming source for partner agent list and “control room for AI agents” framing)
    • InfoWorld coverage of the Notion Developer Platform launch (Tier 2 confirming source)
    • BetaNews and Dataconomy coverage (additional Tier 2 confirming sources)

    This article will need a refresh after August 11, 2026, when the free-pricing window ends and Notion publishes post-window pricing details. The verified-vs-reported standard from our other May 2026 pieces applies — anything beyond what Notion’s own release notes and Anthropic’s customer page confirm has been clearly distinguished.

  • Claude Models Roadmap May 2026: Opus 4.7, Knowledge Cutoffs, the 1M Context Window, and What’s Real About Claude 5

    Claude Models Roadmap May 2026: Opus 4.7, Knowledge Cutoffs, the 1M Context Window, and What’s Real About Claude 5

    Last refreshed: May 15, 2026

    The pace of new Claude releases in 2026 has been fast enough that the canonical question — “what’s the latest Claude model and what’s it actually good for?” — has a different answer almost every quarter. This article is the current map, dated and sourced, of what Anthropic has shipped in 2026, what’s confirmed about each model’s specs and knowledge cutoffs, and what’s been claimed (but not officially confirmed by Anthropic) about what’s coming next.

    Two ground rules first, because the model-roadmap space is full of speculation:

    • Specs and release dates marked as verified come from Anthropic’s own documentation, news posts, or help center pages. We list the specific source.
    • Anything marked as reported or claimed comes from third-party reporting (TechCrunch, secondary news sites, analyst commentary) that we could not independently confirm against an Anthropic-published source as of May 15, 2026.

    If you’re making product decisions on this information, treat verified facts as actionable and reported facts as directional.

    The current generally-available Claude models (May 15, 2026)

    From Anthropic’s official models overview and pricing pages, the current production Claude lineup is:

    Claude Opus 4.7 — claude-opus-4-7

    • Status: Generally available, currently the most capable Claude model
    • Context window: 1 million tokens at standard pricing (no long-context premium)
    • Max output: 128,000 tokens
    • Knowledge cutoff: January 2026 (per Anthropic Help Center, verified May 15, 2026)
    • Pricing: $5/MTok input, $25/MTok output (base rates)
    • Notable changes from 4.6: New tokenizer (uses up to ~35% more tokens for the same text), high-resolution image support up to 2576px / 3.75MP, new xhigh effort level, task budgets beta. Extended thinking budgets and sampling parameters (temperature, top_p, top_k) are removed.

    Claude Opus 4.6 — Still generally available, $5/MTok input, $25/MTok output. Released February 2026.

    Claude Sonnet 4.6 — $3/MTok input, $15/MTok output. Includes the 1M token context window at standard pricing.

    Claude Haiku 4.5 — Cheapest model in the active lineup at $1/MTok input, $5/MTok output.

    Earlier models still active or in deprecation: Opus 4.5, Opus 4.1, Sonnet 4.5, and Haiku 3.5 (retired except on Bedrock and Vertex AI). Opus 4 and Sonnet 4 are listed as deprecated.

    Knowledge cutoff dates that actually matter

    Per Anthropic’s Help Center article on training-data recency (verified May 15, 2026), the most recent generally-available models have January 2026 knowledge cutoffs. That means:

    • Anything that happened after January 2026 is outside the model’s training data
    • For current events, recent product launches, recent legal or regulatory changes, or very recent technical documentation, the model needs to be given the information directly (in the prompt, via web search, or through tool use) — it can’t be relied on to know it
    • The model still has tools available (web search, code execution, file access) that can access post-cutoff information when explicitly invoked

    The practical version: don’t ask Claude what happened last week and expect it to know. Hand it the source material and ask it to analyze, summarize, or work with what you’ve given it.

    The 1M token context window — what it actually unlocks

    Per Anthropic’s official pricing documentation (verified May 15, 2026), Opus 4.7, Opus 4.6, and Sonnet 4.6 all include the full 1 million token context window at standard pricing. There’s no long-context premium — a 900,000-token request is billed at the same per-token rate as a 9,000-token request.

    That’s an enormous practical change from earlier Claude generations. A 1M context window is roughly:

    • ~750,000 words of English text
    • Most full books or technical specifications in a single context
    • ~8 hours of meeting transcripts at typical density
    • An entire mid-sized codebase, including most or all source files

    Prompt caching and batch processing discounts both apply at standard rates across the full 1M window. For workloads that involve sending the same large document repeatedly with different questions, prompt caching against a 1M context is one of the highest-leverage cost optimizations available in the current Claude lineup.

    What’s reported about Claude 5 (and what we cannot independently verify)

    Multiple third-party sources reported in early 2026 that Anthropic CEO Dario Amodei confirmed a Q2 2026 launch window for Claude 5 in a TechCrunch interview published February 1, 2026. The same sources cited an internal-roadmap leak suggesting an April 28 target date.

    What we can verify as of May 15, 2026:

    • Anthropic’s official model lineup, news page, and platform documentation list the latest production models as Opus 4.7 and earlier 4.x variants. Anthropic has not, to our review, published an official “Claude 5” launch announcement on its anthropic.com news page or its docs.claude.com release notes as of this date.
    • The third-party reporting on Claude 5 specifications (500K context window, 20-25% benchmark improvements, ~90%+ on SWE-bench Verified) is widely repeated but, as far as we could verify, is not sourced to an Anthropic-published document.

    The honest read: Q2 2026 ends June 30, so if the reported timeline is accurate, an official Claude 5 announcement could plausibly land in the next several weeks. If you’re planning a project that depends on a specific Claude 5 capability, build against current Opus 4.7 first and treat any Claude 5-specific work as speculative until Anthropic publishes official model details.

    Claude Sonnet 5 — separate question

    Some 2026 third-party reporting refers to “Claude Sonnet 5” launching in early February 2026 under an internal codename. We could not, in our May 15, 2026 review, find this model listed in Anthropic’s official models overview, pricing page, or release notes — only Sonnet 4.6 and earlier Sonnet variants are listed as currently available models. If “Sonnet 5” was a real intermediate release, it does not appear in Anthropic’s current public model documentation under that name.

    Two possibilities to consider, neither of which we can confirm: the reported Sonnet 5 may have been folded into the broader 4.x lineup under a different name, or the reporting may have been speculative or premature. If you’re tracking model identifiers for production use, only model IDs published in Anthropic’s documentation (such as claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5) are guaranteed to be valid against the API.

    How to actually keep up with Claude releases

    The signal-to-noise ratio in the model-release coverage space is not great. Two practical sources are reliable enough to bookmark:

    • Anthropic’s news page at anthropic.com/news — first-party launch announcements with full model details
    • Claude API release notes at the Help Center release-notes page — concise, dated, version-specific

    For breaking changes that affect production code, the Anthropic platform documentation publishes per-version “What’s new” pages (Opus 4.7’s, for example, lists every API breaking change at launch). Those are the canonical reference for migration work.

    For everything else — analyst commentary, predictions, leak coverage — treat it as commentary, not as fact.

    What this means for your work today

    Based on what is verifiable on May 15, 2026:

    • If you need the most capable Claude model available, use Opus 4.7. It has the largest context window, the highest knowledge cutoff (January 2026), and the strongest reported coding/agentic performance.
    • If you need cost-efficient production work, use Sonnet 4.6. Same 1M context, much lower per-token rates than Opus.
    • If you need cheap, fast, simple-task workloads, use Haiku 4.5.
    • If you’re planning around Claude 5, treat the timing as unconfirmed and build resilience into your code (don’t hard-code model IDs that don’t exist yet).
    • For knowledge cutoff-sensitive use cases (current events, recent regulatory data, post-January 2026 news), always provide the information directly or use tool calls — don’t rely on training data alone.

    Frequently Asked Questions

    What is the knowledge cutoff for Claude Opus 4.7?

    January 2026, per Anthropic’s Help Center documentation verified May 15, 2026. Information about events, products, or developments after that date is not in the model’s training data and must be provided directly.

    What is the largest Claude context window currently available?

    1 million tokens, available on Opus 4.7, Opus 4.6, and Sonnet 4.6 at standard pricing with no long-context premium.

    Has Anthropic officially announced Claude 5?

    As of May 15, 2026, we could not locate an Anthropic-published announcement of a Claude 5 model on anthropic.com or docs.claude.com. Multiple third-party sources have reported a Q2 2026 launch window based on a TechCrunch interview with Dario Amodei, but we could not independently confirm those specifications against a primary source.

    Is Claude Sonnet 5 a real model I can use?

    As of May 15, 2026, “Claude Sonnet 5” does not appear in Anthropic’s official models overview or pricing documentation. The currently available Sonnet model is Claude Sonnet 4.6 (model ID claude-sonnet-4-6). Earlier reports of a Sonnet 5 release were not confirmed against an Anthropic-published source in our review.

    Why does Opus 4.7 use more tokens than Opus 4.6 for the same text?

    Opus 4.7 ships with a new tokenizer that contributes to its improved performance but uses approximately 1x to 1.35x as many tokens for the same input text compared to previous models. Anthropic recommends increasing max_tokens headroom and adjusting compaction triggers accordingly.

    Are sampling parameters (temperature, top_p, top_k) still supported on Opus 4.7?

    No. Setting temperature, top_p, or top_k to any non-default value on Opus 4.7 returns a 400 error. Migration guidance: omit these parameters and use prompting to guide the model’s behavior.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Anthropic Pricing Documentation: docs.claude.com/en/docs/about-claude/pricing (primary source for model lineup, per-token rates, context window pricing)
    • Anthropic Platform Documentation: What’s new in Claude Opus 4.7 (primary source for Opus 4.7 features, breaking changes, tokenizer, image support, task budgets)
    • Anthropic Help Center: How up-to-date is Claude’s training data? (primary source for knowledge cutoff dates)
    • Anthropic news page (primary source check for Claude 5 announcement — none located as of May 15, 2026)
    • Third-party reporting on Claude 5 / Sonnet 5 (TechCrunch interview reports, Claude5.com, Fello AI, WaveSpeed Blog) — cited as reported but not independently confirmed against primary sources

    This article applies the verified vs. reported distinction throughout. If any of the unverified third-party claims are confirmed by Anthropic in the weeks after this article’s date stamp, the relevant sections should be updated to reflect the new primary-source documentation.

  • Amazon Prime Student and Claude Pro: Is There a Bundle or Discount? (May 2026 Honest Answer)

    Amazon Prime Student and Claude Pro: Is There a Bundle or Discount? (May 2026 Honest Answer)

    Last refreshed: May 15, 2026

    If you’re a student paying for Amazon Prime Student and you’re wondering whether your subscription includes Claude Pro — or unlocks a discount on it — here’s the direct answer first, and then the supporting context.

    As of May 15, 2026, after reviewing Amazon’s official Prime Student benefits page, Anthropic’s pricing and plans pages, Anthropic’s published news and partnership announcements, and AWS Public Sector publications, we found no announced partnership, bundle, or discount between Amazon Prime Student and Claude Pro.

    That does not confirm such a partnership doesn’t exist or won’t exist later. It confirms that we searched the places you would expect to find an announcement and could not locate one. If Amazon or Anthropic launches this kind of program after the date stamp on this article, this conclusion will be out of date — and the right place to check is always Amazon’s Prime Student benefits page and Anthropic’s own announcements.

    Why people are searching for this

    Search Console data and general 2026 web trends show consistent volume on queries like “amazon prime student claude pro” and “amazon prime student claude code.” The pattern usually reflects one of three things:

    • Students assuming that because Amazon Prime Student bundles several other digital subscriptions and benefits, it would make sense for Claude Pro to be on the list
    • Confusion between Amazon (the retailer/Prime Student parent), AWS (the cloud platform where Anthropic’s Claude is available), and Anthropic (the company that makes Claude)
    • A misread of news coverage about Claude’s availability on AWS Bedrock or AWS Marketplace as some sort of consumer bundle

    None of those are unreasonable assumptions. They’re just not, as far as we can verify in May 2026, actual partnerships.

    What Amazon Prime Student actually includes (as of May 2026)

    Per Amazon’s official Prime Student benefits page, the core benefits are:

    • Six-month free trial, then ~50% off standard Prime pricing
    • Free same-day or one-day shipping on eligible items
    • Prime Video, Amazon Music Prime, and Prime Reading access
    • Exclusive student deals and promotions
    • Bundled access to select third-party services (this list rotates and varies by region)

    Claude Pro is not currently listed among those bundled third-party services. AWS-side products and developer tools are separate from the Prime Student consumer benefit set.

    What students can actually do to access Claude at reduced cost

    Anthropic does not run a public, individual Claude Pro student discount. What it does run, verified May 15, 2026, is a set of institutional and program-based paths to discounted or free access:

    Claude for Education. Launched in April 2025, this is Anthropic’s program for higher-education institutions. Students, faculty, and staff at participating universities get access to Claude’s premium features for free as long as they remain enrolled or employed. Known partner institutions include Northeastern University, the London School of Economics, Champlain College, the University of San Francisco School of Law, and Northumbria University. If your school is part of the program, signing in to claude.ai with your school email upgrades your account automatically — no application or payment required.

    GitHub Student Developer Pack. Verified students enrolled in degree-granting programs can claim a developer pack that has historically included credits or premium access to a wide range of developer tools. Claude offerings within the pack have varied over time — check the current pack contents at GitHub’s education portal for what’s available the day you apply.

    Direct Anthropic partnerships with specific universities. Beyond the formal Claude for Education program, Anthropic has signed individual agreements with universities providing campus-wide access at institutional rates. If your university isn’t on the public partner list, it’s worth asking your IT or library services whether they have a direct arrangement.

    The standard Claude free tier. Anyone can use Claude without paying. The free tier provides limited daily messages on a recent model, and for many students that’s sufficient for coursework that doesn’t require sustained heavy use.

    For a broader breakdown of every legitimate path students can take to reduce Claude costs, see our existing guide: Claude Student Discount: The Honest Guide to Getting Claude for Less.

    What about AWS Marketplace and Claude for Education?

    One source of search confusion is that Claude for Education became available through AWS Marketplace in 2026 (covered in the AWS Public Sector Blog). This is an institutional purchasing path for universities — it allows schools to procure Claude for Education through their existing AWS billing relationship — not a consumer or student-facing benefit.

    It’s also distinct from the underlying availability of Claude models on AWS Bedrock for developers, which is again an enterprise/developer feature, not a Prime Student benefit.

    What to be wary of

    Because there’s real search demand for a Prime Student + Claude Pro discount that doesn’t currently exist, third-party sites have filled the gap with content of varying quality. Specifically:

    • “Promo code” pages claiming 50% off Claude Pro through Prime Student. We could not verify any of these against Anthropic’s official pricing, and Anthropic’s Help Center has stated that support cannot issue one-off discounts.
    • Reseller and account-sharing services that advertise Claude Pro at a discount through some Amazon channel. These typically involve shared logins, terms-of-service violations, or both.
    • YouTube videos and articles that describe a Prime Student / Claude bundle as if it exists — usually republishing each other’s speculation rather than citing a primary source.

    The honest read: until Amazon or Anthropic announces a partnership directly, on their own properties, treat any third-party claim of a Prime Student + Claude Pro discount as unverified.

    What we’d actually like to see

    A Prime Student + Claude Pro bundle would make sense. Prime Student is a credible distribution channel for student-facing digital benefits, Claude is increasingly central to how students do research and writing, and Anthropic has shown it’s willing to do institutional deals for the education market. There’s a logical product collaboration sitting on the table.

    Whether either party is interested in pursuing it isn’t something we can speak to. If it happens, we’ll update this article. If you’ve seen a credible announcement we missed, let us know — the methodology in this article is exactly the kind of finding that should get re-checked when the facts change.

    Frequently Asked Questions

    Does Amazon Prime Student include Claude Pro?

    No, as of May 15, 2026, Amazon Prime Student does not include Claude Pro. We reviewed Amazon’s official Prime Student benefits page, Anthropic’s plans and pricing pages, and Anthropic’s news releases, and found no announced partnership, bundle, or discount linking the two products.

    Is there an Amazon Prime Student discount on Claude Code?

    No, as of May 15, 2026. Claude Code uses the same subscription tiers as Claude Pro (or runs against a Claude Developer Platform API key), and no Amazon Prime Student discount or bundle on either product has been announced through official channels we reviewed.

    Why do search engines suggest “amazon prime student claude pro” if it doesn’t exist?

    Search engines surface query suggestions based on actual user search volume, not on whether the underlying product exists. The high volume of users searching for this combination reflects assumption and curiosity, not a confirmed offering.

    What’s the cheapest legitimate way for a student to use Claude Pro?

    If your university participates in Claude for Education, sign in to claude.ai with your school email — that’s free premium access. If not, the GitHub Student Developer Pack sometimes includes Claude-related benefits. Beyond those, the standard Claude free tier costs nothing, and individual Claude Pro subscriptions are $20/month at standard pricing.

    Can students share a single Claude Pro account to save money?

    Account sharing typically violates Anthropic’s terms of service. The Team plan exists for groups that need multi-user access at a per-seat rate.

    Will Anthropic ever offer a public student discount?

    Unknown. As of May 2026, Anthropic’s stated position is that it focuses student access through institutional Claude for Education partnerships rather than individual discount codes. That could change at any time.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Amazon Prime Student official benefits page (primary source for what Prime Student actually includes)
    • Anthropic pricing page and plans page at claude.com/pricing (primary source for Claude pricing structure and absence of student discount)
    • Anthropic Help Center and news releases (primary source for Claude for Education and partnership announcements)
    • AWS Public Sector Blog: Claude for Education now available in AWS Marketplace (primary source for the AWS Marketplace path)
    • Multiple independent comparison sources (Krater, GamsGo, Get AI Perks, Krater, others) consistently reporting no Prime Student / Claude partnership exists — Tier 2 confirming sources

    This article applies a negative-finding standard: when a claim can’t be verified, we state what we searched and what we did not find, rather than declaring the claim false. If the partnership status changes after May 15, 2026, the conclusion here should be re-verified against the original sources before being treated as current.

  • Claude MCP Token Cost Reality: Why Your Model Context Protocol Setup Is Burning 18,000 Tokens Per Turn

    Claude MCP Token Cost Reality: Why Your Model Context Protocol Setup Is Burning 18,000 Tokens Per Turn

    Last refreshed: May 15, 2026

    If you’ve ever connected a few Model Context Protocol (MCP) servers to Claude Code and watched your usage limit drain faster than the work you actually did would explain, you’re not imagining it. There’s a real, documented, and sometimes substantial token cost to wiring MCP servers into your Claude environment — and most setup guides don’t mention it.

    The short version: each MCP server you connect injects its complete tool schema into the context of every message you send. Multiple servers stack. The total overhead can range from a few thousand tokens for a single server up to roughly 18,000 tokens per turn when you’re running a typical multi-server developer setup. Anthropic’s own engineering team has acknowledged this in a public GitHub issue and shipped optimizations to reduce it.

    This article walks through where the overhead actually comes from, how to measure your own setup, what Anthropic has changed in 2026 to ease the cost, and the concrete steps you can take to keep MCP useful without burning through your token budget.

    What MCP actually is, briefly

    The Model Context Protocol is an open standard created by Anthropic that lets Claude (and other LLMs that adopt the standard) connect to external tools and data sources through a common interface. Instead of writing a custom integration for every API or database you want Claude to access, you point Claude at an MCP server, and the server exposes its capabilities — file access, Slack messages, GitHub repos, database queries — in a format Claude can use.

    It’s a real productivity unlock. It’s also why the token math gets complicated.

    Where the token cost comes from

    When you connect an MCP server to Claude Code (or any MCP-aware client), three things happen on every message:

    1. Tool schema injection. Every tool the server exposes — every name, every description, every parameter definition — is included in the context Claude sees. A Slack MCP server with 10–15 tools typically adds about 2,000 tokens. A GitHub server is heavier. A custom internal-tooling server with verbose descriptions can run 5,000–8,000 tokens on its own.

    2. Tool-use system prompt overhead. Anthropic’s documentation confirms that whenever tools are present in a request, a special system prompt is automatically prepended that teaches the model how to use tools. For Claude 4.x models with tool_choice: auto, that’s an additional 346 tokens per request. The bash tool adds 245. The text editor tool adds 700. The computer-use tool adds 735 plus a 466–499 token system prompt extension.

    3. Stateless re-sending. Each message in a conversation is a fresh API request that includes the full conversation history plus the full tool schema. Claude does not “remember” your tools from the last turn the way a human remembers a colleague’s job description. Every turn pays the schema cost again.

    That’s the math. Now multiply by the number of MCP servers you have connected. A developer running Slack + GitHub + a database connector + an internal custom server can easily land in the 15,000–20,000 tokens-per-turn range — and that’s before you’ve typed your actual question.

    The 18,000-token figure, sourced

    The “up to 18,000 tokens per turn” number comes from a combination of public sources verified May 15, 2026:

    • Anthropic’s own GitHub repo for Claude Code, issue #3406, titled “Built-in tools + MCP descriptions load on first message causing 10–20k token overhead.” Anthropic engineers acknowledged the issue and have shipped progressive optimizations against it.
    • Independent analysis by MindStudio measuring real Claude Code sessions with multiple MCP servers attached.
    • Anthropic’s official Claude Code documentation on cost management explicitly recommends running /mcp to inspect connected servers and disabling unused ones to control token consumption.

    The exact number for your setup will be different. The shape of the problem is the same.

    Why this matters more than it looks

    Claude’s standard context window is 200,000 tokens. Losing 18,000 of those to tool definitions before you start typing represents about 9% of your effective working space. That’s a real ceiling cost — but it’s not the part that hurts most.

    The part that hurts is the cumulative bill. If you’re on a Claude subscription with a usage limit, every turn through Claude Code is paying the full schema cost again. A workflow that takes 30 turns of back-and-forth burns 540,000 tokens worth of tool definitions across that session — even if the tool descriptions never change. On the API at standard Sonnet 4.6 rates, that’s about $1.62 in pure schema overhead per session, before any of the actual work gets billed.

    Multiply by a team of engineers running Claude Code daily, and the overhead becomes the largest single line item in your token spend.

    What Anthropic has changed in 2026

    Anthropic has shipped two meaningful optimizations against MCP token bloat over the past few months:

    Deferred tool loading. In recent Claude Code releases, MCP tool definitions are no longer all loaded into context at the start of a session by default. Tool names enter context, but the full schemas only load when Claude actually invokes a particular tool. This is a substantial improvement for sessions where you have many tools available but only use a few.

    Tool Search. A new built-in search mechanism lets Claude discover relevant MCP tools on demand rather than carrying them all in context. One independent measurement reported a Claude Code MCP context cut of 46.9% — from roughly 51,000 tokens down to 8,500 tokens — by using Tool Search instead of full upfront loading.

    These optimizations help, but they don’t make the overhead zero. The baseline cost of having any MCP server connected at all is real, and you still pay it on every turn even with deferral active.

    How to measure your own MCP token cost

    Two practical methods work for most setups:

    Method 1 — The /mcp command. In Claude Code, run /mcp to see every server currently connected. For each one, check how many tools it exposes. Anthropic’s documentation explicitly recommends this as the first step to controlling MCP costs.

    Method 2 — Token-count delta. Send a single message in Claude Code with no MCP servers connected and note the input token count from the API response. Reconnect your MCP servers one at a time. The delta in input tokens between configurations is the per-turn cost of each server. This is the most precise way to know your own number.

    Anything north of about 8,000 tokens per turn in pure MCP overhead is worth optimizing. North of 15,000 is a flag.

    Concrete steps to control MCP token cost

    • Disable MCP servers you aren’t actively using. The single highest-leverage move. If you connected a server two weeks ago for one experiment and never went back to it, every turn you’ve taken since has been paying for it.
    • Prefer CLI tools over MCP servers when both exist. Anthropic’s own cost-management guidance notes that tools like gh, aws, gcloud, and sentry-cli remain more context-efficient than equivalent MCP servers because they don’t add per-tool listing overhead. Claude can simply invoke them via the bash tool.
    • Use MCP gateways for large server counts. If you genuinely need many tools available, gateway products (Maxim, Milvus-backed setups, others) consolidate tools and surface only relevant ones per query, cutting net overhead substantially.
    • Run a complex CLAUDE.md audit. Long project-level CLAUDE.md files compound the per-turn baseline. Treat CLAUDE.md as an asset that’s expensive to keep verbose.
    • Watch for context compounding. In long Claude Code sessions, conversation history grows alongside the tool schema cost. If you’re running a workflow longer than 20 turns, periodically clear context (/clear) to reset the per-turn cost to baseline.

    Frequently Asked Questions

    Does every MCP server cost 18,000 tokens?

    No. The 18,000-token figure is for a typical multi-server setup with several connected servers and built-in tools active. A single small MCP server (5–10 tools, concise descriptions) might only add 1,500–3,000 tokens. The cost scales with the number of servers and the verbosity of their tool definitions.

    Why does Claude reload the tool definitions every turn?

    The Claude API is stateless. Every message is a fresh API request containing the full conversation history and the full tool schema. The model has no memory between requests, so the schema must be present every time tools could be used. Recent deferred-loading optimizations reduce this for unused tools, but anything Claude actually needs still loads each turn.

    How do I see what’s loaded in my Claude Code environment?

    Run /mcp in Claude Code to list every connected MCP server and its tool count. To check the actual token cost, send a test message and inspect the input token count returned by the API.

    Are CLI tools really cheaper than MCP servers?

    Yes, for tools that have both options. CLI tools accessed via the bash tool only add the bash tool’s 245-token overhead. An equivalent MCP server adds its full tool schema for every tool it exposes. For tools you use frequently, MCP can still be worth it for the structured interface; for tools you use rarely, CLI is more efficient.

    Does this affect Claude on the web (claude.ai) too?

    Web Claude does not use the same MCP server-connection model as Claude Code. The MCP token-overhead pattern primarily affects Claude Code, custom Agent SDK applications, and other developer-facing clients where you wire in MCP servers directly.

    Will this get better in future Claude releases?

    Likely. Anthropic has already shipped deferred tool loading and Tool Search in 2026, both of which materially reduce the per-turn overhead for unused tools. The architectural baseline (tools must be present in context to be invoked) is unlikely to change, but the practical cost should keep dropping as the deferred-loading optimizations mature.

    Related Reading

    How we sourced this

    Sources reviewed May 15, 2026:

    • Anthropic GitHub: anthropics/claude-code issue #3406, “Built-in tools + MCP descriptions load on first message causing 10-20k token overhead” (primary source for the overhead figure and Anthropic acknowledgment)
    • Anthropic Claude Code documentation: Connect Claude Code to tools via MCP and Manage costs effectively (primary source for /mcp command and CLI vs. MCP guidance)
    • Anthropic Pricing Documentation: tool-use system prompt token counts, bash/text-editor/computer-use overheads (primary source for the per-tool fixed costs)
    • Independent analysis: MindStudio (multiple Claude Code MCP measurements), Joe Njenga’s Tool Search 51K→8.5K measurement, Maxim and Scott Spence on optimization patterns (Tier 2 confirming sources)

    Token-cost numbers in this article are accurate as of May 15, 2026. Anthropic is shipping MCP optimizations regularly, so the practical overhead may be lower in your environment than what’s described here.

  • Claude Agent SDK Dual-Bucket Billing: What Changes June 15, 2026 (And Why It Matters)

    Claude Agent SDK Dual-Bucket Billing: What Changes June 15, 2026 (And Why It Matters)

    Last refreshed: May 15, 2026

    If you’ve been running Claude Code’s claude -p command in production, kicking off background jobs through the Claude Agent SDK, or wiring the Agent SDK into a third-party app, the way you pay for that work is about to change.

    Starting June 15, 2026, Anthropic is splitting Claude subscription billing into two separate buckets: one for the things you do interactively (Claude.ai chat, Claude Code in your terminal, Claude Cowork), and a brand-new credit pool that only covers programmatic, autonomous, and SDK-driven work.

    This is a meaningful shift. It’s also one of the most under-explained changes Anthropic has made to subscription pricing this year. If you don’t know about it before June 15, you can find yourself with stopped automations, surprise overage charges, or both.

    This guide walks through exactly what’s changing, what the credits cover, what they don’t cover, what each plan gets, and how to plan for it before the cutover.

    The short version

    Claude subscription plans (Pro, Max, Team, Enterprise) currently have one shared usage limit. Whether you’re chatting with Claude on the web, using Claude Code in your terminal, or running unattended jobs through the Agent SDK, all of that draws from the same plan-level allowance.

    On June 15, 2026, Anthropic is separating those two modes of use:

    • Bucket 1 — Interactive use: Claude.ai chat, Claude Code in the terminal/IDE, Claude Cowork. Uses your existing subscription usage limits, exactly as before.
    • Bucket 2 — Agent SDK monthly credit: A separate, dollar-denominated credit pool. Funds the Claude Agent SDK, the claude -p non-interactive command, the Claude Code GitHub Actions integration, and any third-party app that authenticates via the Agent SDK.

    The two buckets do not commingle. Agent SDK work cannot draw from your interactive subscription limit, and interactive use cannot draw from your Agent SDK credit. If you exhaust your Agent SDK credit and don’t have extra usage enabled, your background jobs simply stop until the credit refreshes the following month.

    What each plan gets

    Here is the official monthly Agent SDK credit by plan, as published in Anthropic’s Help Center (verified May 15, 2026):

    • Pro: $20/month
    • Max 5x: $100/month
    • Max 20x: $200/month
    • Team — Standard seats: $20/month per seat
    • Team — Premium seats: $100/month per seat
    • Enterprise — usage-based: $20/month
    • Enterprise — seat-based Premium seats: $200/month

    Important detail buried in the announcement: Enterprise seat-based plans on Standard seats are not eligible to claim the Agent SDK credit at all. If you administer one of those plans and have engineers running automation, that’s a gap to plan around.

    What the credit covers (and what it doesn’t)

    Anthropic’s documentation is specific about what counts as Agent SDK use, so this is worth reading carefully.

    Covered by the credit:

    • Claude Agent SDK usage in your own Python or TypeScript projects
    • The claude -p command in Claude Code (non-interactive mode)
    • The Claude Code GitHub Actions integration
    • Third-party apps that authenticate with your Claude subscription through the Agent SDK

    Not covered (these still draw from your normal subscription limits):

    • Interactive Claude Code in your terminal or IDE
    • Claude conversations on web, desktop, or mobile
    • Claude Cowork
    • Other features that draw from extra usage

    The plain-English version: if a human is sitting at the keyboard waiting for the response, that’s interactive use. If a script kicks off the work and the result lands somewhere else later, that’s Agent SDK use.

    How the credit actually works in practice

    Five mechanics matter for budgeting:

    1. Per-user, never pooled. Each eligible user on a Team or Enterprise plan claims their own credit. There is no organization-level pool. Credits cannot be transferred between users, shared, or stockpiled across accounts.

    2. Refreshes monthly with the billing cycle. Whatever you don’t spend in a given month evaporates. Unused credits do not roll over.

    3. One-time opt-in. You claim your credit through your Claude account once. After that initial claim, it refreshes automatically each cycle.

    4. Drains first, before any other source. When an Agent SDK request fires, it pulls from your monthly credit before any other paid usage source kicks in. This is good — it means you actually use what you’ve already paid for.

    5. After the credit, requests either flow to extra usage or stop entirely. When your monthly credit hits zero, additional Agent SDK requests draw from extra usage at standard API rates — but only if you have extra usage enabled. If you haven’t enabled extra usage, your Agent SDK requests stop until the next refresh.

    That last point is the one most likely to bite teams. If you’re running a daily cron job through the Agent SDK and you don’t enable extra usage, the day your credit runs out is the day your automation goes silent — without obvious warning if you’re not watching the credit balance.

    Why Anthropic is doing this

    Anthropic frames this as separating individual experimentation from production automation. From the Help Center documentation: “The Agent SDK monthly credit is sized for individual experimentation and automation. Teams running shared production automation should use the Claude Developer Platform with an API key for predictable pay-as-you-go billing.”

    The translation: a single user’s $20 or $200 of Agent SDK credit was never going to cover a real production workload anyway. Anthropic is making explicit what was already true under the hood — that a subscription was a chat product, and serious unattended automation belongs on the API.

    What this also does, structurally, is protect interactive subscription users from getting their experience degraded by heavy autonomous workloads sharing the same pool. If you’ve ever hit a subscription rate limit during a normal chat session because something else on your account was burning tokens in the background, this change removes that failure mode.

    What you should do before June 15, 2026

    If you run any unattended Claude work (the most important group):

    Audit every place your subscription is being used by something other than a human at a keyboard. The big four to check:

    • claude -p commands in cron jobs, CI pipelines, or shell scripts
    • Claude Code GitHub Actions workflows
    • Custom Python or TypeScript projects using the Agent SDK
    • Any third-party tool that asks for “Sign in with Claude” — those go through the Agent SDK

    For each one, estimate dollar consumption per day at standard API rates. If the total approaches or exceeds your plan’s Agent SDK monthly credit, you have three options: enable extra usage to allow overage, move that workload to a Claude Developer Platform API key (more predictable for sustained loads), or downsize the workload itself.

    If you administer a Team or Enterprise plan:

    Eligible users on your team will receive an email with claim instructions before June 15, 2026. You don’t need to take action yourself, but it’s worth communicating internally that the credits are per-user, can’t be pooled, and that any team-wide automation should be on an API key, not on a subscription seat.

    If you’re a solo Pro or Max user who only chats with Claude:

    You probably don’t need to do anything. The split affects you only if you’re running scripts or background jobs. If you’ve never used claude -p or the Agent SDK directly, your interactive usage limits don’t change.

    Frequently Asked Questions

    What happens to my Agent SDK usage on June 14 vs. June 15, 2026?

    Before June 15, Agent SDK and claude -p usage counts against your subscription’s general usage limits. Starting June 15, that same usage no longer touches your subscription limits and instead draws from the new Agent SDK monthly credit pool. Your interactive Claude Code, web chat, and Cowork usage continues to work exactly as before.

    Can I share the Agent SDK credit across my team?

    No. Per Anthropic’s official documentation, “Credits are per-user. Each eligible user on your team claims their own credit. Credits can’t be pooled, transferred, or shared across the organization.” If your team needs shared automation budget, the Claude Developer Platform with an API key is the recommended path.

    Do unused Agent SDK credits roll over?

    No. Unused credits expire at the end of each billing cycle and do not carry into the next month.

    What happens if I run out of Agent SDK credit mid-month?

    If you have extra usage enabled, additional requests flow to extra usage at standard API rates (the same per-token prices listed in Anthropic’s pricing documentation). If extra usage is not enabled, your Agent SDK requests stop until your credit refreshes at the start of the next billing cycle.

    Does this affect Claude API customers using their own API key?

    No. If you authenticate with the Agent SDK using a Claude Developer Platform API key, nothing changes. Pay-as-you-go billing continues, and you do not receive an Agent SDK monthly credit. The credit only applies to subscription-authenticated Agent SDK use.

    Is interactive Claude Code in my terminal still covered by my subscription?

    Yes. Interactive Claude Code (typing commands and getting responses in your terminal or IDE) continues to draw from your subscription usage limits exactly as before. Only the non-interactive claude -p mode and direct Agent SDK calls move to the new credit pool.

    What’s the dollar value of the credit on each plan?

    As of May 15, 2026: Pro $20, Max 5x $100, Max 20x $200, Team Standard $20/seat, Team Premium $100/seat, Enterprise usage-based $20, Enterprise seat-based Premium $200. Enterprise seat-based Standard seats do not receive a credit.

    Related Reading

    How we sourced this

    Every factual claim in this article was triple-checked across the following sources, all reviewed on May 15, 2026:

    • Anthropic Help Center: Use the Claude Agent SDK with your Claude plan (primary source for credit amounts, eligibility, and mechanics)
    • Anthropic Pricing Documentation: docs.claude.com/en/docs/about-claude/pricing (primary source for standard API rates and tool-use pricing)
    • Independent press coverage from The New Stack, The Decoder, and InfoWorld confirming the announcement and its scope

    If you spot a number that’s drifted out of sync with Anthropic’s current published rates, treat the official documentation as authoritative. The pricing surface around Claude is moving quickly in 2026, and we date-stamp specifics so readers know which facts to re-verify.

  • Claude Code Pricing in May 2026: What $20, $100, and $200 a Month Actually Buy You

    Claude Code Pricing in May 2026: What $20, $100, and $200 a Month Actually Buy You

    Last refreshed: May 15, 2026

    Claude Code pricing has stopped being a clean sticker number and started being a question of which ceiling you hit first. There is a $20 plan, a $100 plan, and a $200 plan — and underneath all three sits a 5-hour rolling window, a weekly active-hours cap added in August 2025, and a per-model multiplier that quietly makes Opus 4.7 the most expensive thing you can do inside the terminal. If you came looking for the right plan, the honest answer is: it depends on whether you are mostly a Sonnet operator or you live in Opus.

    The three subscription tiers, stripped down

    Pro — $20/month. Access to Claude Code in the terminal, web, and desktop, with both Sonnet 4.6 and Opus 4.7 available. The practical envelope is about 44,000 tokens per 5-hour window and roughly 40–80 weekly active hours on Sonnet, depending on session concurrency. This is the plan for someone running Claude Code a few hours a day on focused work — refactors, scoped feature builds, debugging passes — not someone leaving an agent running while they eat lunch.

    Max 5x — $100/month. Five times the Pro envelope, plus priority during peak demand. The window allocation lands around 88,000 tokens per 5-hour block. This is the tier where you stop thinking about token budgets during a single working day and start thinking about them across a whole week. Picked correctly, it is the cheapest way to use Claude Code as your primary IDE companion without flipping over to API billing.

    Max 20x — $200/month. Twenty times Pro — about 220,000 tokens per window — which translates to roughly 480 Sonnet-hours or about 40 Opus-hours per week before the weekly cap kicks in. Real-world reports from early 2026 had $200/month users watching single Opus prompts eat 10–20% of their daily allocation; Anthropic publicly acknowledged the problem, expanded capacity, and doubled the 5-hour rate limit for Pro and Max accounts. If you are running Claude Code across multiple repos all week and reaching for Opus on the hard problems, this is the tier that stops you from staring at a rate-limit wall.

    The API, as a sanity check

    If you want a sanity check on whether the subscription math works, price the same workload against the API:

    • Claude Haiku 4.5 (claude-haiku-4-5-20251001): $1.00 input / $5.00 output per million tokens
    • Claude Sonnet 4.6 (claude-sonnet-4-6): $3.00 input / $15.00 output per million tokens
    • Claude Opus 4.7 (claude-opus-4-7): $5.00 input / $25.00 output per million tokens

    Prompt caching is the lever almost nobody uses correctly. Cache writes cost 1.25x input price for the 5-minute TTL or 2.0x for the 1-hour TTL, but cache reads cost 0.10x — a 90% discount on every subsequent request that hits the same context. If your .clauderules file, project map, and the file you are editing are all stable for an hour, the bill on a long pairing session can drop by an order of magnitude. The Batch API knocks another 50% off both directions for asynchronous workloads, which is worth knowing if you are running large refactor sweeps.

    One trap on Opus 4.7 specifically: the model uses a new tokenizer that inflates token counts by up to 35% on identical text compared to Opus 4.6. The headline price did not change, but your effective spend per request did — sometimes by nothing, sometimes by a third, depending on the content. If you migrated from Opus 4.6 and your bill went up without your prompt patterns changing, that is the reason.

    How to actually choose

    The cleanest way to pick a plan is to first decide your model mix, then your weekly hours.

    If you are mostly a Sonnet operator — long agentic runs, multi-file edits, codebase Q&A, with Opus only reached for on the architectural questions — Pro at $20 is plausible up to about 5–8 hours of focused use per day, Max 5x covers most full-time individual developers, and Max 20x is overkill unless you are running multiple sessions in parallel.

    If you live in Opus — long-horizon agentic work, hard refactors across many files, anything where you would rather have one good attempt than three Sonnet retries — Pro will frustrate you within two weeks, Max 5x is the realistic floor, and Max 20x is the only tier that gives you a defensible Opus envelope without bouncing over to API billing.

    And if you are running Claude Code across multiple repos all week, leaving agents to grind on tasks while you do other things, Max 20x is the only subscription that holds up — and even then, the weekly cap is real. Use the API for the spillover and you will still come out cheaper than trying to brute-force a smaller plan.

    The number that matters

    One developer’s public report this year: roughly 10 billion tokens consumed across Claude Code over eight months. API metered cost would have exceeded $15,000. The same workload on Max at $100/month for the same window came in around $800 — about 93% cheaper. That is the gap that makes the subscription model worth taking seriously, even when the rate limits feel arbitrary. The $200 tier is not a vanity number; it is the price Anthropic charges to stop being a meaningful constraint on your workflow.

    The right way to read Claude Code pricing in May 2026 is not to ask which plan is cheapest. It is to ask which plan is the cheapest one that disappears — the one that stops appearing in your day. For most full-time developers reaching for Opus regularly, that plan is Max 20x. For everyone else, Max 5x is the first plan that actually gets out of your way.