What is a Claude Code router?

A Claude Code router is any layer — Anthropic's built-in defaults, a third-party tool like OpenRouter, or custom code — that decides which Claude model handles a given request.

Does Claude Code have built-in routing?

Partial. Claude Code picks a default model (Sonnet) and routes internal sub-agent tasks to lighter models. It does not automatically promote your main session to Opus when a task gets hard.

What's the difference between OpenRouter and a custom router?

OpenRouter is a hosted multi-provider gateway with billing and fallback built in. A custom router is something you build to enforce your own rules.

Should I use OpenRouter with Claude Code?

Useful if you want fallback, multi-provider mixing, or unified billing. Less useful if you only use Claude and want Anthropic-specific features.

How do I pick the right Claude model for a task?

Default Sonnet. Opus for hard reasoning, architectural decisions, ambiguous specs. Haiku for high-volume formulaic tasks.

How much can routing save me?

For volume users, 40-60% versus running everything on Opus, with no measurable drop in output quality if the routing rules are sensible.

Is there a cost to routing through OpenRouter?

OpenRouter adds a small markup on token pricing in exchange for routing and aggregation features. Very high volume users go direct to Anthropic for lower cost.

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; the long tail of cheaper models barely moved the needle.

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.

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 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 take more than 40 seconds to produce a final answer. This breaks any timeout policy shared with single-call models.

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.

Tag: Claude

Why the Best AI Operators Think Small: Lessons from the “Token Wall”
There’s a moment every serious Claude user hits eventually. You’re mid-session, deep in the flow of building a workflow, a content pipeline, or a complex research thread. You’ve built something substantial, and you’re right on the verge of a breakthrough.

Then the model goes quiet. Or it returns something strange and vague. Or it just stops mid-sentence.

You didn’t break anything. You simply ran out of room. You’ve hit the "Token Wall," and understanding how to navigate this limit is what separates a casual user from a master operator.

1. The Physics of the Whiteboard

Every AI conversation has a "context window," which is essentially a fixed amount of memory the model can hold at once. Think of it like a whiteboard. Every message you send, every response the model generates, every task list, and every snippet of code takes up space on that board.

When you get close to the limit, the model doesn't just shut off; it begins to struggle under the weight of its own history. You might notice the "feel" of a session getting heavy. The model starts to lose its edge, often attempting to "pattern-match on noise" within the context rather than following your instructions.

Crucially, the smarter the model, the faster it hits the wall. This is the Opus Paradox: Claude Opus thinks deeply and writes extensively. Because its outputs are more verbose and nuanced, it consumes its own runway far more aggressively than a simpler model. Its intelligence is the very thing that accelerates its failure in a crowded session. When the board is full, the model tries to squeeze a new request into a space that doesn’t exist, resulting in the graceful—but frustrating—failures we’ve all experienced.

2. The Haiku Trick: Precision Over Power

When a session stalls at the context limit, your first instinct might be to switch to an even more powerful model. That is almost always the wrong move.

The veteran operator’s secret is to go smaller. Claude Haiku—the lightest and fastest model—can often "squeeze through the gap" that a heavier model like Opus or Sonnet simply cannot fit through. Because Haiku is lean and efficient, it can perform surgical actions like updating a task list, summarizing the current state of play, or triggering a "compaction" of the history. This small action clears the whiteboard just enough to unlock the entire session.

"It's not always about raw intelligence. It's about fit. The right tool for the moment isn't the most powerful one — it's the one that can actually execute given the constraints you're operating in."

This shift from seeking raw power to seeking operational fit is a fundamental breakthrough. It’s the realization that the most "intelligent" move is often the one that creates the most momentum with the least amount of space.

3. The Formula One Mindset: Strategy Outruns Raw Compute

To excel in the new era of AI, you have to embrace the Formula One analogy. F1 teams spend hundreds of millions on the fastest cars, but the car doesn't win the race on its own. The driver wins by knowing when to push the engine, when to conserve tires, and when to pit.

The AI is your car; you are the driver. Two people using the exact same model will produce radically different results based on their "driver skills." These aren't skills you find in a manual; they are earned through "hours in the seat." A master operator develops an instinct for:
- Pruning Context and History: Recognizing the moment a session feels "heavy" and manually clearing the whiteboard to keep the model focused.
- Strategic Model Swapping: Knowing exactly when to call in the heavy lifting of Opus and when to pivot to the lean navigation of Haiku.
- Compacting and Resetting: Identifying when a conversation has become too polluted with noise and needs a clean summary before starting fresh.
- Task Handoffs to Subagents: Understanding that a subagent operating in isolation will almost always outperform a single, mile-long thread where context is diluted.
4. What Agents Teach Us About Human Momentum

We often focus on making AI more like humans, but the more valuable lesson is learning what agents can teach us about our own productivity.

Agents succeed when they have a bounded context, a defined task, and honest signals about their capacity. They fail when their context is polluted with noise, when tasks are ambiguous, or when they try to do too much in one pass. This is a perfect mirror for human cognitive load. When we are overwhelmed, it’s rarely because we aren't "smart" enough for the task—it's because our internal whiteboard is full of distraction and noise.

"When you're overwhelmed and stuck, the answer usually isn't to think harder. It's to do the smallest possible thing that creates forward momentum."

Just as Haiku unlocks a stalled AI session by clearing one small item, humans can overcome paralysis by making one small decision or finishing one minor task. Operating intelligently within your own mental constraints is a superpower, not a compromise.

5. The Internalized Hybrid

The most effective AI users aren't just "humans using tools." They are "internalized hybrids"—operators who have adopted the logic of agentic thinking as their own.

They naturally break massive projects into discrete, manageable tasks. They are honest about their own "context limits," realizing that pushing through a complex task at 11:00 PM is the cognitive equivalent of a model producing garbage when its whiteboard is full.

This level of mastery isn't taught in a tutorial. It’s forged in the "Machine Room" at midnight, in those moments of operational failure when you hit the token wall and realize that a smaller, smarter approach is the only way through the gap. You have to live the experience of the work to develop the instinct for it.

Conclusion: Getting Back in the Seat

The relationship between you and the AI is defined by the "Driver and the Car." The car provides the potential for incredible speed, but it is the driver who provides the strategy, the timing, and the environmental awareness required to reach the finish line.

The technology is now available to everyone, which means the tool itself is no longer the competitive advantage. The advantage is the operator.

As you return to your workflows, ask yourself: Are you just pressing harder on the accelerator and wondering why you’re hitting a wall? Or are you ready to become a true driver, managing your context and choosing the right tool for the moment?

The car is waiting. The driver makes the difference. It’s time to get back in the seat.
May 28, 2026
Claude Orchestrates, Gemini Executes: A Multi-CLI Production Run
The Architecture of Delegation: Moving Beyond the Chat Interface

I spent today wiring Claude Code to boss around the Gemini CLI, clearing a 1,256-post WordPress tagging backlog without a single hallucinated tag. If you operate an agency or manage technical strategy at any reasonable scale, you already know the fundamental truth about current AI tools: the chat interface is a massive bottleneck. Copying, pasting, and waiting for a typing animation isn’t a workflow; it’s theater. Real, scalable throughput requires system-to-system communication and architectural delegation.

The goal for today wasn’t just to write a python script. The goal was to establish a functional hierarchy between two distinct AI systems operating locally on my machine. Claude Code, operating directly in my terminal, would act as the lead engineer and orchestrator. It would handle the logic, map out the API calls, write the Python bridges, and manage the error handling. Gemini, accessed via its official command-line interface, would act as the high-context, high-throughput worker.

The setup was brutally simple but effective. I installed the Gemini CLI using a standard node package manager command (npm install -g @google/gemini-cli) and authenticated it with a Google One AI Ultra account. This gave my local environment direct, command-line access to Google’s most capable models without needing to manage raw API keys or custom curl requests. From there, Claude Code was instructed to shell out via bash, calling the gemini command non-interactively to pass massive data payloads for processing, and then ingesting the structured output back into the orchestration pipeline.

It is an assembly line in the truest sense. Claude builds the machinery and defines the parameters; Gemini operates the heavy press, stamping out classifications at a volume that would break a standard chat context window.

Quantifying the Backlog and the Taxonomy Threat

Before you throw compute at a problem, you have to measure it accurately. I directed Claude to run a full audit of tygartmedia.com using the native WordPress REST API. The numbers came back clean, but the scale of the maintenance debt was daunting.
- Total published posts: 2,529 individual pieces of content.
- SEO infrastructure: RankMath confirmed healthy and active across the board.
- Existing tag vocabulary: 931 distinct, strategically established tags.
- The deficit: 1,256 posts sitting entirely untagged, orphaned from the site’s primary taxonomy.
In the past, solving this was a lose-lose proposition. It was either a job for a junior employee spending three agonizing weeks in the wp-admin panel, or it was a job for a messy automated script that inevitably hallucinates a thousand new, slightly misspelled tags. When you let an LLM tag 1,256 posts without strict, physical constraints, you don’t get an organized site. You get “Marketing”, “marketing”, “digital-marketing”, and “Digital Marketing Strategy” added as four completely separate taxonomy terms, permanently bloating your wp_terms table and diluting your internal link equity.

The constraint I set for this pipeline was absolute. The system had to read the 1,256 untagged posts, assign 5 to 8 highly relevant tags to each post, and only use tags from the exact 931-item vocabulary we already had. Zero deviation. Zero hallucination. If a perfect tag didn’t exist in the vocabulary, the system had to settle for the closest existing match rather than inventing a new one.

The Pilot Test and the Strict JSON Constraint

We started small to validate the pipeline. Claude pulled a pilot batch of 10 untagged posts from the WordPress API, along with the complete, raw list of 931 acceptable tags. It packaged this massive block of text into a single, dense prompt and fired it over to the Gemini CLI.

The instruction was clear and unforgiving: read the text of the posts, evaluate them against the vocabulary, and return ONLY a valid JSON object. I did not want markdown formatting. I did not want a polite introductory sentence. I needed a raw JSON string mapping each specific post_id to an array of its assigned tag IDs.

If you’ve spent any significant time wrestling with large language models, you know that asking for strict adherence to a vocabulary and strict, unformatted JSON output is exactly where things usually break down. Models inherently want to chat. They want to explain their reasoning. They want to invent a 932nd tag because it felt slightly more semantically accurate for a specific paragraph.

Gemini didn’t flinch. It processed the prompt and returned a raw, perfectly formatted JSON string directly to the standard output. Claude parsed it in memory, validated the suggested tags against the local vocabulary list, and found a 100% match rate. Every single tag suggested by Gemini was real. There was no conversational filler, no missing structural brackets, and no invented taxonomy. Claude immediately took that JSON, formatted the correct POST requests, and pushed the updates back to WordPress via the REST API.

Scaling Up: Hitting the Windows Bottlenecks

With the pilot completely successful, it was time to scale. Processing 1,256 posts one by one is inefficient, both in terms of time and system calls. We grouped the remaining posts into chunks of 25. This meant Claude would need to loop through roughly 50 distinct batches. For each batch, it would dynamically construct the prompt with the 931 tags and the 25 new post payloads, call Gemini, parse the resulting JSON, and patch the WordPress database.

That is where the friction started. Building a local orchestration pipeline means you are no longer just dealing with AI limitations; you are dealing with local OS limits. Windows had two specific, technical walls waiting for us.

Failure 1: WinError 2 (File Not Found)
The initial Python orchestration script used the standard subprocess.run(['gemini', '-p', prompt]) command to invoke the CLI. It failed almost immediately with a WinError 2. The issue? When npm installs global packages on a Windows machine, it doesn’t create a raw binary; it creates a .cmd wrapper. Python’s subprocess module doesn’t automatically resolve these wrappers unless you pass shell=True, which introduces a host of security and string parsing headaches. The clean, robust fix was forcing Claude to locate the executable and use the absolute, fully qualified path to gemini.cmd in the subprocess call. It’s a minor detail, but one that breaks entire automation pipelines if you don’t know what you’re looking at.

Failure 2: “The command line is too long”
Once the executable actually resolved, the script crashed again on the very first batch. Windows threw a fatal error: “The command line is too long.” Windows enforces a strict character limit on command-line arguments—roughly 8,191 characters depending on the exact environment. Our dynamically generated prompt, containing the full text of 25 blog posts and 931 taxonomy terms, hovered around 20KB. Trying to pass that payload via the standard -p argument flag was physically impossible for the operating system to handle.

The solution was architectural. Instead of trying to cram the prompt into an argument, Claude rewrote the Python script to pipe the prompt directly into Gemini’s standard input (stdin). By restructuring the workflow to write the 20KB payload to a temporary text file on disk, and then piping it via a standard input redirect (gemini < prompt.txt), we bypassed the OS argument limit entirely. The data flowed, and the pipeline spun back up to full speed.

The Verdict: The Orchestrator vs. The Worker

Watching this script hum through 50 consecutive batches crystalized a specific, actionable opinion about the current state of local agentic workflows. You do not need one god-model to do everything; you need specialized roles operating within a hierarchy.

Claude Code is unmatched as an orchestrator. It understands the local filesystem, it navigates REST API documentation with ease, it writes robust, defensive Python, and it can dynamically debug Windows-specific OS errors on the fly. But using Claude for the repetitive, high-volume, token-heavy classification of thousands of posts is an expensive and slow use of a strategic brain. It is the equivalent of having your lead architect nailing drywall.

Gemini, operating locally via its CLI, proved to be the ultimate high-throughput worker. It absorbed the massive context window of 931 tags and 25 full articles simultaneously, over and over again, without degrading in quality. It maintained absolute discipline over the JSON output structure across 50 separate invocations. It didn’t need to understand how the WordPress API worked, and it didn’t need to know how to write Python. It only needed to process the classification task it was handed and get out of the way.

When Gemini acts as the worker and Claude acts as the boss, you get the absolute best of both architectures. You get the system-level problem-solving and environmental awareness of Claude, combined with the raw, reliable, high-context processing power of Gemini.

Tomorrow’s Takeaway

If you operate an agency and have a massive backlog of unstructured data—whether it is untagged content, uncategorized financial transactions, or messy CRM records—stop trying to fix it manually inside a browser window. The chat interface is dead for real, scalable work.

Tomorrow, install an agentic CLI like Claude Code. Give it access to a high-context execution model via a secondary CLI, like Gemini. Tell the orchestrator to write a local script that batches your data, hands the batches to the execution model, forces a strict, structured JSON return, and posts the results directly back to your database or CMS. Expect the script to break on local OS limits. Fix the pipes, use standard input instead of arguments for massive payloads, and let the machines clear the backlog while you focus on actual strategy.
May 28, 2026

Foreman and Crew: Why My Best Claude Work Actually Runs on Gemini

The Economics of Cognitive Budget

Every automated system has a cognitive budget. When you are building an AI agency or managing a large-scale content pipeline, that budget is measured in two ways: the literal dollar cost of API credits and the “judgment tokens” spent on complex reasoning. Claude, specifically the 3.x and 4.x Sonnet and Opus series, currently holds the crown for high-judgment work. It understands nuance, follows complex instructions, and writes with a cadence that feels human. But it is also a resource you have to husband carefully.

The most expensive mistake an operator can make is burning Claude’s judgment tokens on labor that requires zero creativity. If a task involves a fixed vocabulary, a strict JSON schema, and a predictable input-output loop, you don’t need a poet; you need a foreman to watch a crew of laborers. In my current architecture, Claude is the Foreman—the one who decides the strategy and handles the edge cases—while Gemini serves as the Crew. This isn’t just about saving a few dollars on a Tuesday; it’s about architectural resilience and maximizing the throughput of your most capable models.

Yesterday, I detailed the orchestration pattern that allows these two models to talk to each other. Today, I want to look at the raw numbers and the operational rationale behind why my best Claude work actually runs on Gemini hardware. When you stop treating LLMs as a single-vendor solution and start treating them as tiered compute, the math of your business changes overnight.

The Tygart Media Benchmark: 1,000 Posts and 931 Tags

To understand the “Foreman and Crew” model, we have to look at a concrete production environment. We recently moved over 1,000 legacy posts for Tygart Media through a full metadata audit. This wasn’t a “write a summary” task. This was a “categorize these posts using only these 931 specific tags” task. This is what we call a bounded subtask. The model cannot invent new tags. It cannot be “creative.” It must map unstructured text to a strictly defined vocabulary.

Running this through Claude Opus or even Sonnet 3.5 is technically superior in terms of accuracy, but the cost-to-benefit ratio is skewed. Gemini, particularly when accessed through a Google One AI Premium subscription, allows for a “marginal zero” cost structure for high-volume, bounded tasks. We processed 50 batches, involving approximately 300,000 input tokens and 25,000 output tokens. Here is how that breaks down against the current market rates for Claude models:

Model Tier	Input (300K)	Output (25K)	Total Cost	Estimated Annual (20 Clients)
Claude Sonnet 3.5 ($3/$15)	$0.90	$0.38	$1.28	$307.20
Claude Opus ($15/$75)	$4.50	$1.88	$6.38	$1,531.20
Gemini (AI Ultra Subscription)	$0.00*	$0.00*	$0.00	$0.00

*Cost is covered by the existing $19.99/mo subscription already used for storage and workspace tools.

A $6 saving in a single day is a rounding error. But scale that across 20 client sites on a monthly cadence, and you are looking at $1,500 a year in reclaimed margin. More importantly, you are preserving Claude’s rate limits for the tasks Gemini cannot do—like the actual synthesis of the articles or the high-level strategy decisions that Claude 3.5 handles with far more grace.

Defining the Bounded Subtask

The success of this model hinges on knowing where the Foreman ends and the Crew begins. You cannot simply ask Gemini to “write like Claude.” It won’t. Gemini’s prose style often leans toward the repetitive or the overly structured. However, Gemini excels at what I call Bounded Subtasks. These are tasks where the “walls” of the output are clearly defined.

A bounded subtask has three characteristics:

Fixed Vocabulary: The model must choose from a provided list (like our 931-tag library) rather than generating new ideas.
Structural Rigidity: The output must be valid JSON or a specific markdown format. Gemini is exceptionally good at following “System Instructions” that demand valid code blocks.
Low Context Sensitivity: The task doesn’t require “remembering” what happened three articles ago. It only needs the text in front of it and the rules provided.

By routing these specific “labor” tasks to Gemini, we ensure that zero hallucinations occur. When you give Gemini 931 tags and tell it “only use these,” its adherence to those boundaries is remarkably stable. In our Tygart Media run of 1,000 posts, we saw zero instances of the model inventing a tag that wasn’t in the provided schema. That is the “Crew” doing exactly what they were told, while the “Foreman” (Claude) is free to handle the complex orchestration logic in the background.

The Marginal Zero: Subscription Arbitrage

There is a psychological shift that happens when you move from “consumption-based billing” (API) to “subscription-based billing” (Google One). When you are paying by the token, every experiment feels like a withdrawal from a bank account. You hesitate to run a second pass. You skip the extra validation step to save $0.15.

When you use Gemini through the AI Ultra subscription (routed through a local bridge or automated CLI), the marginal cost of the next 100,000 tokens is zero. This changes the way you build. You can afford to be “wasteful” with tokens to ensure quality. You can run three different prompts on the same text and have the Foreman (Claude) pick the best one. This “Subscription Arbitrage” is the secret weapon of the independent operator. You are already paying for the Google storage and the workspace; why not use the compute that comes bundled with it to handle your data processing?

This doesn’t mean Gemini is “better” than Claude. It means Gemini is “cheaper labor” for the specific tasks where its performance is “good enough.” In engineering, “good enough” at zero marginal cost is almost always superior to “perfect” at a premium.

Architectural Resilience and Multi-Vendor Strategy

Beyond the cost, there is the matter of resilience. If your entire agency or software stack is built on a single LLM provider, you are not a business; you are a feature of that provider. Rate limits, outages, or sudden changes in model weights can break your pipeline in an afternoon.

By splitting the workload between Claude (Foreman) and Gemini (Crew), you build a multi-vendor layer into your architecture by default. If Anthropic has a service disruption, the Crew can still process the tagging and the data—perhaps with a slightly more manual oversight—while you wait for the Foreman to come back online. If Google throttles your subscription, you can temporarily route the Crew’s work to Claude Sonnet.

This decoupling is essential for systems thinkers. It allows you to swap out components without re-writing the entire logic of your application. Your “Foreman” logic stays the same; you just change which “Crew” you are sending the batches to. This is the difference between building a fragile script and building a durable system.

What You Should Do Tomorrow

If you are currently running a pipeline that relies solely on Claude, I am not suggesting you switch. I am suggesting you audit. Look at your logs and identify the tasks that don’t require Claude’s soul. Look for the tagging, the JSON formatting, the data extraction, and the basic categorization.

Tomorrow, try this protocol:

Isolate one bounded task: Pick something with a fixed input and a predictable output.
Set up a Gemini bridge: Use the API or a subscription-linked CLI to route that specific task.
Keep Claude as the orchestrator: Let Claude handle the “why” and the “how,” but let Gemini handle the “what.”
Measure the token savings: Don’t just look at the dollars. Look at how many Claude rate-limit tokens you’ve reclaimed for higher-value work.

The goal isn’t to use less AI; it’s to use the right AI for the right job. My best work runs on Gemini because it allows Claude to be the best version of itself. Stop hiring master carpenters to move boxes. Hire the crew, keep the foreman, and scale the system.

May 28, 2026

Claude Code’s Rate Limit Doubling: What May 2026 Changed and How to Pick a Plan Now
If you bought a Claude Code subscription in March or April and felt like you were hitting the 5-hour wall every single afternoon, you weren’t imagining it. Anthropic spent six months tightening Claude Code’s quotas — and then, over two weeks in May 2026, gave most of them back. The rate-limit math that drove plan-selection advice on the internet through April is now obsolete. Here’s what actually changed, what the numbers look like today, and how to think about Pro versus Max if you’re picking a plan this week.

What Anthropic actually did

On May 6, 2026, Anthropic doubled the 5-hour rate limits on Claude Code across every paid plan — Pro, Max 5x, Max 20x, Team Premium, and seat-based Enterprise. In the same announcement, they removed the peak-hour throttle that had been quietly halving available quota for Pro and Max users during weekday business hours. They also lifted API-side rate limits on the Opus tier.

One week later, on May 13, 2026, they followed up with a 50% increase to the weekly cap across the same plans. Unlike the 5-hour change, that weekly bump carries an expiration date: July 13, 2026, unless extended. Treat it as a temporary boost, not a permanent feature.

The trigger Anthropic pointed to is a deal that brings the full capacity of the Colossus 1 data center in Memphis online — over 300 megawatts and roughly 220,000 NVIDIA GPUs. That detail matters less than the practical one: capacity-driven throttling that had been the dominant constraint since late 2025 has loosened.

The new numbers, by plan

The shape of the plan ladder hasn’t changed — Pro at $20, Max 5x at $100, Max 20x at $200, Team Premium at $100/seat with a 5-seat minimum. What changed is what each tier actually delivers per window.
- Pro ($20/mo): Roughly 90 prompts per 5-hour window now (up from a number that, in practice, was hovering around 45 once the peak-hour throttle kicked in). No peak penalty. Weekly cap is 50% higher through July 13.
- Max 5x ($100/mo): Same doubled 5-hour window. Weekly Opus 4.7 budget moved from approximately 50 hours to approximately 75.
- Max 20x ($200/mo): Doubled 5-hour window. Weekly Opus 4.7 budget moved from approximately 200 hours to approximately 300.
- Team Premium ($100/seat/mo, annual; $125 monthly): Mirrors Max 5x quotas at the seat level. 5-seat minimum still applies.
Two numbers that haven’t changed: the API pay-as-you-go pricing for the underlying models (claude-sonnet-4-6 at roughly $3 per million input tokens and $15 per million output; claude-opus-4-7 at roughly $5 in and $25 out), and the existence of the weekly cap itself. The weekly cap is still the thing that kills Max users mid-Friday.

What this changes about plan selection

Most of the “which plan should I buy” guides written before May 6 over-recommend Max 5x because they were sizing it against artificially compressed Pro limits. With a doubled 5-hour cap and no peak throttle, Pro at $20 is now genuinely enough for a developer doing focused coding sessions a few hours a day — something that wasn’t reliably true a month ago.

The Max 5x case still holds, but it’s narrower now. The honest test: if you regularly burn through your Pro 5-hour window before lunch, or if you run two or three concurrent Claude Code sessions on different repos, $100 still pays for itself. If you don’t, Pro will hold.

Max 20x is increasingly a workflow choice rather than a quota choice. The doubled limits made Max 5x sufficient for almost every solo workflow I can describe. Where 20x still earns its price is multi-agent workflows, where a coordinator-and-workers pattern can burn three to seven times the tokens of a single-agent session because every teammate maintains its own context window.

The hidden costs that didn’t change

The rate-limit relief is real, but several gotchas that drove “Claude Code costs me more than I expected” complaints in Q1 are still live:
- Set ANTHROPIC_API_KEY in your shell and Claude Code bills at API rates — your subscription is silently ignored. Unset it before launching the CLI if you’re on a plan.
- Weekly caps count active processing time only. Idle browsing is free. Long-running tool calls and extended-thinking budgets aren’t.
- Extended thinking is billed as output tokens. On Opus 4.7 that’s roughly $25 per million. Default thinking budgets of tens of thousands of tokens per request stack up fast on API.
- MCP server output sits in context for the rest of the session. A “list the last 20 PRs” call can dump 8,000 tokens of metadata that you’ll re-pay for on every subsequent turn until the conversation rolls over.
If you were running into the 5-hour wall and assumed it was a usage problem, check whether one of those four is actually the cause before you upgrade.

What to do this week

If you’re on Pro and were considering Max 5x, wait two weeks. The new Pro ceiling is high enough that the upgrade decision now needs different evidence than it did in April.

If you’re already on Max 5x and felt squeezed, the May 13 weekly bump should give you breathing room — but mark July 13 on your calendar. If the temporary 50% increase isn’t extended, the squeeze comes back.

If you’re picking a plan from scratch today: start on Pro. The doubled limits are real, the peak-hour penalty is gone, and the upgrade path to Max stays open with no friction. Buy quota when you’ve measured that you need it, not before.

The model versions to use

For anyone writing the API string into a script this week: flagship is claude-opus-4-7, workhorse is claude-sonnet-4-6, fast tier is claude-haiku-4-5-20251001. Pull from docs.anthropic.com/en/docs/about-claude/models before shipping anything — the version strings have moved twice already this year and they’ll move again.
May 28, 2026

Claude Code Plan Mode: How to Use It, When to Skip It (2026 Guide)

Published: May 25, 2026 | Last fact-check: May 25, 2026 against Anthropic docs and Claude Code v2.1+ behavior

Quick Answer

Plan Mode is a Claude Code setting that forces the agent to think through and approve a plan before taking destructive actions. Trigger it with Shift+Tab pressed twice in the terminal (the first press cycles to Auto-Accept Mode; the second lands on Plan Mode). Use it for risky multi-step work; skip it for simple read-only or contained edits.

How to enable it, when it pays off, and when it gets in your way below.

Plan Mode (sometimes called “planning mode”) is one of the more underused features in Claude Code in 2026. It changes how the agent works in a specific, measurable way: before Claude Code edits files, runs commands, or modifies state, it produces a plan and waits for your approval. You see what it intends to do, you say yes or no, and only then does it act.

For the right kind of task, Plan Mode is the difference between a clean execution and a regrettable one. For the wrong kind of task, it is friction that slows you down. This guide separates the two.

Claude Code Plan Mode vs Auto Mode: When to Use Each

Scenario	Use Plan Mode	Use Auto Mode
Unfamiliar codebase	Yes — review the plan first	Only if you know it well
Large multi-file refactor	Yes — catch scope creep early	Not recommended
Simple bug fix (< 5 lines)	Overkill	Yes
Adding a new feature	Yes — plan clarifies approach	Acceptable for small features
Writing tests	Optional	Yes, usually safe
Touching database migrations	Yes — irreversible changes	No
CI/CD pipeline changes	Yes	No

What Plan Mode Actually Does

In default mode, Claude Code is allowed to take actions as it reasons. It can read files, write files, run bash, edit code, all in one conversational flow. This is the strength of Claude Code as an agent — it gets work done without asking permission for every step.

In Plan Mode, Claude Code’s behavior changes:

You describe the task.
Claude Code investigates the codebase (read-only operations are still allowed).
Claude Code drafts a plan listing every file it intends to change, every command it intends to run, and every decision point.
You read the plan. You approve it, modify it, or reject it.
Only after approval does Claude Code start writing files or running commands.

The plan is presented in the terminal as a structured outline. You can ask Claude Code to revise the plan, add steps, remove steps, or change the order. Iterating on the plan is fast because no actions have been taken yet.

How to Enable Plan Mode

There are four ways to activate Plan Mode in Claude Code:

Shift+Tab pressed twice. Each press of Shift+Tab cycles through the three permission modes: Default → Auto-Accept → Plan → Default. Two presses lands on Plan Mode. The status bar shows ⏸ plan mode on when active.
The /plan slash command. Type /plan at the start of any prompt to enter Plan Mode for that turn only. Useful for one-off plans without flipping the whole session.
The –permission-mode plan flag at startup. Start the session in Plan Mode from the command line.
Headless mode for scripts and CI. claude --print --permission-mode plan "your task" for automation that should never edit files.

# Start session in Plan Mode
claude --permission-mode plan

# Or mid-session — press Shift+Tab TWICE
# (first press = Auto-Accept Mode, second press = Plan Mode)

# Or one-shot Plan Mode for next prompt only
/plan

Plan Mode is persistent within a session — it stays on until you cycle out with another Shift+Tab. Close and reopen Claude Code and it defaults back to off. Toggle it on for risky work, leave it on for the whole session if you are doing higher-risk work end-to-end.

Important: Plan Mode is a hard read-only sandbox enforced at the tool level. Claude Code physically cannot edit files, run commands, or modify state while Plan Mode is active. This is not a suggestion or a soft check — the write tools are unavailable.

When Plan Mode Pays Off

Plan Mode is worth the friction in these situations:

Multi-file refactors. When the agent will touch 5+ files, you want to see the list before it starts editing. A small confusion about which files to change becomes a big mess fast.
Database migrations or schema changes. Anything that touches durable state and is hard to undo benefits from a confirmed plan.
Production code paths. If a session affects code that ships to users, the plan checkpoint is cheap insurance.
Ambiguous instructions. When you are not sure how the agent will interpret your request, Plan Mode surfaces the interpretation before any work happens.
New repository onboarding. When you do not yet know the codebase well, Plan Mode lets the agent show you what it learned during investigation before it acts.
Long-running batch jobs. Approving a plan for 200 file edits and then walking away is safer than launching 200 edits blind.

When Plan Mode Gets In the Way

Plan Mode is not free. The friction it adds is a real cost for certain workflows:

Single-file tweaks. Asking Claude Code to fix a typo or rename a variable does not need a plan. The plan takes longer than the fix.
Tight feedback loops. When you are iterating quickly — try a change, see the result, adjust — Plan Mode slows the loop. Default mode wins here.
Read-only investigation. If you are asking questions about the codebase (“how does this auth flow work”), there is nothing to plan. Plan Mode is irrelevant.
Work in a sandbox. If you are working in a throwaway directory or branch where mistakes are cheap, the safety net of Plan Mode is overkill.

The decision is not “is Plan Mode good.” It is “is the cost of approval less than the cost of an unintended action.” For risky multi-step work, yes. For cheap iteration, no.

Working Inside the Plan

Once Claude Code presents a plan, you have several options:

Approve as-is. Tell Claude Code to proceed. It executes the plan in order.
Approve with modifications. Tell Claude Code to remove specific steps, reorder them, or add additional steps. It revises the plan and re-presents.
Ask questions. Drill into specific steps. “Why are you editing file X?” Claude Code explains the reasoning.
Reject and restart. If the plan is wrong-shape, tell Claude Code so. It will rebuild the plan from a corrected understanding.
Cancel. Exit Plan Mode entirely if you’ve decided this is not the right task or session for it.

The plan is conversational. You are not stuck with the first draft. Iterating on the plan is much cheaper than iterating after the work is done.

What Plan Mode Does Not Protect Against

Plan Mode is not a sandbox. The plan, once approved, executes for real. Plan Mode does not:

Prevent you from approving a bad plan
Catch logic errors inside individual file edits
Prevent destructive bash commands if you approved them in the plan
Replace tests or code review

It is a thinking checkpoint, not a safety net. The human still owns the decision.

Plan Mode vs Other Safety Patterns

Plan Mode is one of several safety patterns Claude Code supports:

Read-only sessions: Restrict the agent to read operations only.
Per-tool permissions: Approve each tool use individually as it happens.
Plan Mode: Approve a batch of intended actions before execution begins.
Auto-accept mode: The opposite — accept all tool uses without asking. Fast and risky.

Per-tool permission is more granular but slower. Plan Mode is bulkier but faster once approved. Use the right tool for the situation; do not assume one is always correct.

A Working Habit

The habit that has worked across hundreds of Claude Code sessions: default mode on, Shift+Tab twice into Plan Mode before any session that will (a) touch production state, (b) edit more than 5 files, or (c) run commands that are hard to undo. Shift+Tab again to cycle back to default for everything else.

The shortcut becomes muscle memory in a week. Once it is muscle memory, the cost of Plan Mode drops to nearly zero, and you can use it liberally on anything that even smells risky.

Frequently Asked Questions

What is Plan Mode in Claude Code?

Plan Mode is a Claude Code setting that forces the agent to produce a written plan and wait for your approval before making changes. It surfaces what the agent intends to do so you can adjust it before any work happens.

How do I enable Plan Mode in Claude Code?

Press Shift+Tab twice in the terminal (the first press cycles to Auto-Accept; the second lands on Plan Mode), type /plan as a slash command, or start the session with –permission-mode plan. The status bar shows ⏸ plan mode on when active.

When should I use Plan Mode?

For multi-file refactors, database migrations, production code paths, ambiguous instructions, new repositories you don’t know yet, and long-running batch jobs. Skip Plan Mode for single-file tweaks, tight iteration loops, and read-only investigation.

Does Plan Mode make Claude Code slower?

Yes, for short tasks — the plan adds latency that is not worth it on quick edits. For long or risky tasks, the plan is faster than fixing mistakes afterward.

Can I edit the plan before approving it?

Yes. Tell Claude Code to revise the plan — add steps, remove steps, reorder. Iterating on the plan is much cheaper than iterating after execution.

Is Plan Mode the same as a sandbox?

Plan Mode IS a hard read-only sandbox at the tool level — Claude Code cannot write files or run commands while it’s active. But once you approve the plan and exit Plan Mode, the work executes for real. Plan Mode prevents accidental writes during planning; it does not prevent you from approving a bad plan.

What’s the difference between Plan Mode and per-tool permissions?

Per-tool permissions ask you to approve each tool use individually as it happens (more granular, slower). Plan Mode batches all intended actions into one plan you approve up front (bulkier, faster once approved).

The Bottom Line

Plan Mode is leverage for risky work and friction for everything else. Make Shift+Tab+Shift+Tab muscle memory. Use Plan Mode whenever the cost of an unintended action exceeds the cost of approval — multi-file refactors, production changes, ambiguous specs. Skip it on cheap iteration. That single rule will save you more headaches than any other Claude Code habit.

May 25, 2026

Claude Code Router: Model Routing, OpenRouter & Custom Rules in 2026
Published: May 25, 2026 | Last fact-check: May 25, 2026 — current model lineup: Opus 4.7, Sonnet 4.6, Haiku 4.5

Quick Answer

A Claude Code router is any layer that decides which Claude model handles which request — Opus for hard reasoning, Sonnet for daily work, Haiku for fast cheap tasks. Anthropic ships some built-in routing, but the most leveraged users build their own routing rules on top to optimize cost and latency.

Built-in routing, manual model selection, and the third-party router landscape below.

“Claude Code router” is a phrase that means different things to different people in 2026, and the differences matter for what you should actually build or buy.

It can mean (1) Anthropic’s built-in logic that picks a model when you do not specify one, (2) third-party tools that route between Anthropic models and other LLMs through one Claude Code interface, or (3) custom routing rules you build yourself to match models to tasks. This guide walks through each, when each makes sense, and the trade-offs.

Why Routing Matters in the First Place

Claude is not one model. It is a family. As of 2026 the production tiers are roughly:
- Claude Opus 4.7 — $5/$25 per million tokens. Current flagship. Best for hard, ambiguous, multi-step reasoning and agentic coding.
- Claude Sonnet 4.6 — $3/$15 per million tokens. The workhorse. Within ~1 point of Opus on coding benchmarks at 40% less cost. Right answer for 80% of daily work.
- Claude Haiku 4.5 — $1/$5 per million tokens. Fast and cheap. Right answer for high-volume formulaic tasks: classification, extraction, formatting, routing, simple Q&A.
Output costs 5x input across all three tiers. Prompt caching cuts cached input costs by ~90%. Batch API cuts everything by 50% if you can wait up to 24 hours.

Using Opus for everything is wasteful. Using Haiku for everything is sloppy. Routing — matching the model to the task — is how you get the best output for the lowest cost. For someone running Claude Code several hours a day, intelligent routing is the difference between a $100/month Max bill and a $1,000/month API bill for the same work.

Anthropic’s Built-In Claude Code Routing

When you launch Claude Code without specifying a model, it picks a default. As of 2026 the default for most users is Sonnet, with Opus accessible via flags or settings, and Haiku used internally for some sub-tasks like tool selection and simple file operations.

You can override the default at session start:
```
# Start Claude Code with Opus for a tough refactor
claude --model claude-opus-4-7   # current flagship

# Or set it in your settings.json
{
  "model": "claude-sonnet-4-6"  // current workhorse
}
```
Anthropic also routes internally: when Claude Code uses sub-agents for parallel work, it can route those sub-agents to lighter models automatically. This routing is opaque to you and generally well-tuned. You usually do not need to think about it.

Manual Model Selection: The 80/20 Approach

For most users, manual routing beats automatic routing. The rule:
- Sonnet by default. Daily work, content drafts, code edits, file operations, debugging.
- Opus when you hit a wall. Architectural decisions, hard refactors, ambiguous specs, anything that requires real reasoning.
- Haiku for batch. Classification, taxonomy assignment, metadata generation, SEO meta descriptions, anything formulaic at volume.
This 80/20 split is achievable with two or three commands and zero infrastructure. It is the right starting point.

Third-Party Claude Code Routers

A small ecosystem has emerged around third-party routers that sit between Claude Code and the model layer. The two most common patterns:

OpenRouter and Multi-Provider Routers

OpenRouter is the most widely used third-party router. You point Claude Code at OpenRouter as the API endpoint, and OpenRouter routes your requests to Claude (or to GPT, Gemini, DeepSeek, Llama, etc.). Why use it:
- You want fallback when Anthropic has an outage.
- You want to mix Claude with other models on a per-task basis.
- You want a single billing surface across providers.
- You want BYOK (bring your own key) routing where you mix your own provider keys.
The trade-off: latency adds a few hundred milliseconds per call, and some Anthropic-specific features (prompt caching, certain beta tools) work less smoothly through the proxy.

Custom In-House Routers

Larger teams build their own routing layer. A typical pattern: a small Python or TypeScript service that inspects the incoming request, applies routing rules (length thresholds, task type detection, cost ceilings), picks a model, and forwards the call to Anthropic.

This is overkill for most individuals. It pays off when you have:
- Strict cost controls that need enforcement, not suggestion
- Multi-tenant usage where different customers get different models
- Compliance requirements that need request inspection and logging
- A real engineering team that can maintain the service
Routing Rules That Actually Work

If you are going to invest in any routing logic, these are the rules that pay back:
1. By task type. Code review → Opus. New code generation → Sonnet. Format conversion → Haiku.
2. By input length. Long context (40K+ tokens) where you need careful reasoning → Opus. Long context where you need extraction → Sonnet with prompt caching.
3. By cost ceiling. Anything over a threshold token count gets a hard cap or downgrade.
4. By time of day. Overnight batch jobs route to cheaper models. Interactive daytime work routes to your preferred quality tier.
5. By failure recovery. If a Sonnet call returns a low-confidence or refused response, retry once with Opus before giving up.
Most of these rules are five lines of code each. The discipline is more about deciding the rules than implementing them.

What Anthropic Does Not Yet Ship

As of writing, Anthropic does not ship a built-in “route this query to the right model” intelligence layer in Claude Code. The model you set is the model you get for the session, with the exception of internal sub-agent routing.

This is likely to change. The shape of where Claude Code is going — more autonomy, longer sessions, more parallel agents — implies more sophisticated internal routing. For now, the routing decisions worth making are the ones you make yourself.

Costs: What Routing Actually Saves

Concrete example. An operator running a Claude Code content pipeline that:
- Drafts articles (Sonnet): 8,000 input + 4,000 output tokens per article
- Generates SEO meta and FAQ (Haiku): 2,000 + 500 tokens
- Reviews and edits (Opus): 10,000 + 2,000 tokens for trickier articles
Running everything on Opus would roughly triple the cost. Running everything on Sonnet would save vs Opus but produce noticeably weaker meta-generation than Haiku at similar quality. Routing by task type saves real money — often 40-60% versus a single-model approach — without sacrificing output quality.

When Not to Build a Router

Routing is leverage when you operate at volume. If you run Claude Code casually — a couple of hours a day, one task at a time — you do not need a router. You need to learn the three models well enough to pick the right one by feel. Build a router only when (a) cost is a real line item in your budget, (b) you are running multiple workflows that have genuinely different model needs, or (c) you want fallback infrastructure for resilience.

Frequently Asked Questions

What is a Claude Code router?

A Claude Code router is any layer — Anthropic’s built-in defaults, a third-party tool like OpenRouter, or custom code — that decides which Claude model handles a given request.

Does Claude Code have built-in routing?

Partial. Claude Code picks a default model (Sonnet) and routes internal sub-agent tasks to lighter models. It does not automatically promote your main session to Opus when a task gets hard.

What’s the difference between OpenRouter and a custom router?

OpenRouter is a hosted multi-provider gateway with billing and fallback built in. A custom router is something you build to enforce your own rules. OpenRouter is right for most teams. Custom routers are right for teams with strict requirements.

Should I use OpenRouter with Claude Code?

Useful if you want fallback, multi-provider mixing, or unified billing. Less useful if you only use Claude and want Anthropic-specific features like prompt caching to work optimally.

How do I pick the right Claude model for a task?

Default Sonnet. Opus for hard reasoning, architectural decisions, ambiguous specs. Haiku for high-volume formulaic tasks (classification, formatting, metadata).

How much can routing save me?

For volume users, 40-60% versus running everything on Opus, with no measurable drop in output quality if the routing rules are sensible.

Is there a cost to routing through OpenRouter?

OpenRouter adds a small markup on token pricing in exchange for the routing and aggregation features. For most users this is acceptable; for very high volume, going direct to Anthropic is cheaper.

The Bottom Line

Claude Code routing is leverage when you operate at volume and a distraction when you do not. Start by learning the three Claude models by feel and picking manually. Add OpenRouter if you want fallback. Build a custom router only when cost or compliance actually justifies the engineering. The router is not the goal; the right model on the right task is the goal.
May 25, 2026

Anthropic API Key: Pricing, Security, Rotation & Management (2026)

Published: May 25, 2026 | Last verified: June 28, 2026 (Pacific Time)

Quick Answer

Get an Anthropic API key at console.anthropic.com → API Keys → Create Key. The key starts with sk-ant- and is shown once — copy and store it in a password manager immediately. Add billing credits before making API calls.

Full setup, security, and usage walkthrough below.

An Anthropic API key is the credential that lets your application, script, or tool call Claude programmatically. Whether you are wiring Claude into Claude Code, building an internal agent, or integrating Claude into a SaaS product, the API key is the first step. This is the complete reference for that key — pricing, billing, security, rotation, and organization controls. If you just need to create your first key, our step-by-step guide to getting an Anthropic API key walks through it in about five minutes; this page is what you read next.

Anthropic API Pricing Tiers (June 2026)

Model	API ID	Input (per MTok)	Output (per MTok)	Context
Claude Fable 5 NEW	claude-fable-5	$10.00	$50.00	1M tokens
Claude Opus 4.8	claude-opus-4-8	$5.00	$25.00	1M tokens
Claude Sonnet 4.6	claude-sonnet-4-6	$3.00	$15.00	1M tokens
Claude Haiku 4.5	claude-haiku-4-5-20251001	$1.00	$5.00	200K tokens

All models support 50% Batch API discount for non-real-time requests. Fable 5 is free on Pro/Max/Team through June 22, 2026. Prices verified June 12, 2026.

What an Anthropic API Key Is (and Isn’t)

The Anthropic API key authenticates requests to the Anthropic Messages API. It identifies which workspace and organization is making the call, what model permissions it has, and where to bill the token usage.

What an API key is not: a login. You cannot use an API key to sign into claude.ai. The web interface and the API are separate billing surfaces. Your Pro or Max subscription does not grant API credit by default; API usage requires its own billing setup.

Creating a key (the short version)

Create a key at console.anthropic.com → API Keys → Create Key; it starts with sk-ant-, is shown once, and will not work until billing is added. For the full walkthrough — including the no-key OAuth option and the four errors that trip people up on the first request — see our step-by-step guide to getting an Anthropic API key. The rest of this page is the reference you will want once the key exists.

Adding Billing Before You Can Use the Key

A common surprise: a freshly created API key cannot make calls until you add a payment method and credits to your Anthropic account. The key exists, but every request returns a billing error.

To add billing:

In the Claude Console, click “Billing” or “Plans & Billing” in the left sidebar.
Add a payment method (credit card; Anthropic also supports invoicing for enterprise).
Either pre-purchase API credits or enable auto-recharge. Most users enable auto-recharge with a low threshold to avoid hitting empty mid-job.
Set a monthly usage limit if you want a safety cap.

Once billing is set up, your API key works.

Anthropic API Key Format

An Anthropic API key starts with the prefix sk-ant- followed by a long alphanumeric string. The full key is roughly 100 characters. If your key does not start with sk-ant-, you have copied something incomplete.

Different key types exist:

Live keys (sk-ant-api...): Production calls, real billing.
Admin keys (sk-ant-admin...): Workspace admin operations, not for inference calls.

Most developers only need a live key.

Which Claude Models the API Key Works With

A standard live API key gives you access to the current generation of Claude models:

Claude Fable 5 (claude-fable-5) — current top tier, released June 9 2026. $10/$50 per million tokens. Anthropic’s first Mythos-class model. Note: carries a mandatory 30-day data retention requirement (no zero data retention option). Full breakdown here.
Claude Opus 4.8 (claude-opus-4-8) — second tier, released April 16 2026. $5/$25 per million tokens. Supports zero data retention.
Claude Sonnet 4.6 (claude-sonnet-4-6) — released February 17 2026. $3/$15 per million tokens. The production default for most workloads.
Claude Haiku 4.5 (claude-haiku-4-5) — released October 15 2025. $1/$5 per million tokens. Fast and cheap for high-volume work.

Earlier model versions (Sonnet 4, Opus 4.6, Haiku 3.5, etc.) are still callable by their specific snapshot IDs until Anthropic announces deprecation. Check the deprecation timeline in the Claude Console for any model you depend on in production.

How to Use the API Key

You pass the key in the x-api-key header on every request to the Messages API:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-4-8",
    // Other current options: claude-sonnet-4-6, claude-haiku-4-5
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello"}]
  }'

In Python or Node.js, the official SDKs read ANTHROPIC_API_KEY from your environment automatically. You should never hardcode the key in source code.

Security: How to Not Leak Your Key

Anthropic API keys leak constantly. Most leaks happen the same way:

Committing the key to a public GitHub repo. The single most common leak. GitHub scans for known credential patterns and notifies Anthropic; your key gets auto-revoked within minutes. You will know because your calls suddenly start failing.
Pasting the key into a shared chat or document. Anyone with access becomes a credential holder.
Putting the key in client-side JavaScript. A browser app shipping its API key to users is giving the key away. Always proxy through a backend.
Logging the key. Any logging system that captures HTTP headers can leak the key. Mask sensitive headers in your logger config.

The good rule: treat your API key like a credit card number, because that’s what it functions as.

Rotating an Anthropic API Key

You should rotate keys quarterly at minimum, and immediately if a key is suspected compromised. Rotation in the Claude Console:

Go to API Keys.
Create a new key with a fresh name (e.g., “Claude Code Laptop 2026 Q3”).
Update your application’s environment variable or secret manager to use the new key.
Verify the new key works.
Revoke the old key.

The five-minute rotation is far cheaper than dealing with a leaked key that was used by an attacker for hours before you noticed.

Workspace and Organization Keys

Anthropic accounts are organized as: Organization → Workspaces → API Keys. Most individuals only use one of each. Teams use multiple workspaces to separate environments (production, staging, dev) or projects.

Each key belongs to one workspace. Billing rolls up to the organization. If you need separate billing visibility per project, separate workspaces are the lever.

Monitoring API Key Usage

The Claude Console shows per-key usage in the “Usage” section. You can see:

Token spend per key per day
Model breakdown (Opus, Sonnet, Haiku usage)
Input vs output token split
Cache usage (if you have prompt caching enabled)

Set up usage alerts in Billing. The Anthropic console can email you when daily or monthly spend crosses a threshold. This is the cheapest insurance against a runaway loop or compromised key.

Frequently Asked Questions

How do I get an Anthropic API key?

Sign in to console.anthropic.com, open API Keys in the sidebar, click Create Key, name it, and copy the key immediately. You cannot retrieve the full key after closing the creation modal.

Is the Anthropic API key free?

The key itself is free to generate. Using it costs money — Anthropic bills per token at the API pricing in effect. You must add billing credits before the key works.

Does my Claude Pro or Max subscription include API credits?

No. Pro and Max subscriptions cover the chat interface and Claude Code (with usage caps). API usage is billed separately against your Anthropic account.

What does an Anthropic API key start with?

Live API keys start with sk-ant-api. Admin keys start with sk-ant-admin. The key is roughly 100 characters long.

What happens if my Anthropic API key gets leaked?

Anyone with the key can use it to make API calls billed to your account until the key is revoked. If you suspect a leak, revoke immediately in the Claude Console and check Usage for any suspicious activity.

Can I use the same API key for Claude Code and my own app?

You can, but you should not. Use separate keys per environment (Claude Code Laptop, Production Backend, Local Dev). Separate keys make revocation surgical instead of catastrophic.

Where should I store my Anthropic API key?

In a password manager (1Password, Bitwarden) for personal use, or in a secret manager (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault) for production. Never commit it to a repo or hardcode it in source.

How do I rotate an Anthropic API key?

Create a new key in the Claude Console, update your application to use the new key, verify it works, then revoke the old key. Rotate quarterly as a baseline.

Get alerted when Claude pricing or limits change

We track Anthropic’s models, pricing, and limits daily and send a short note when something changes that affects what you pay or build. Occasional, no spam.

The Bottom Line

Getting an Anthropic API key is a three-minute process. Keeping it safe is a discipline. Use a password manager, rotate quarterly, never put the key in client-side code, and set usage alerts in the Claude Console. Treat the key as production infrastructure, not a developer toy, and it will serve you for years without incident.

You have your key. Now hit the ground running.

The Solo Builder Seed Kit includes a ready-made Claude skill file, 20 tested prompts for solo operators, and a step-by-step setup guide. Paste your API key, install the skill, and you’re building — $47.

Get the Solo Builder Kit →

Frequently Asked Questions

How do I get an Anthropic API key?

Go to console.anthropic.com, sign in or create an account, then navigate to Settings > API Keys. Click ‘Create Key’, give it a name, and copy the key immediately — it is only shown once. You’ll need to add a credit card and funds to your account before making API calls.

Is there a free tier for the Anthropic API?

Anthropic does not offer a persistent free tier for the API. New accounts may receive a small initial credit to test the API. After that, all usage is billed at standard token rates. The free tier of claude.ai (the chat interface) is separate from API access.

How much does the Anthropic API cost?

As of June 2026: Claude Haiku 4.5 costs $1 input / $5 output per million tokens. Claude Sonnet 4.6 costs $3/$15. Claude Opus 4.8 costs $5/$25. Claude Fable 5 (newest, released June 9) costs $10/$50 per million tokens. The Batch API offers 50% off for non-real-time workloads.

How do I keep my Anthropic API key secure?

Never commit API keys to version control. Store them in environment variables or a secrets manager (AWS Secrets Manager, GCP Secret Manager, Vault). Use separate keys per application so you can rotate or revoke them independently. Set spending limits in the Anthropic console to cap accidental runaway costs.

What happens if my Anthropic API key is compromised?

Go to console.anthropic.com > Settings > API Keys immediately and click Revoke next to the compromised key. Create a new key and rotate it into your applications. Review your usage logs for unexpected spend. Anthropic will not refund charges made with a compromised key unless you contact support promptly.

Can I use my Anthropic API key with Claude Code and Claude Cowork?

Claude Code (the CLI tool) uses your API key when you run it outside a claude.ai subscription context. Claude Cowork (the desktop app) uses your subscription, not a raw API key. For self-hosted integrations, scripts, and Agent SDK workflows, your API key from console.anthropic.com is what you need.

May 25, 2026

Claude Code Pricing in 2026: Pro vs Max vs API Costs Explained

Published: June 9, 2026 | Last fact-check: June 10, 2026 against Anthropic’s pricing page. Rates change — always verify at anthropic.com/pricing before commitments.

Quick Answer

Claude Code is included with Pro ($20/month), Max 5x ($100/month), Max 20x ($200/month), and Team Premium seats ($100/seat annual, 5-seat minimum). Team Standard does NOT include Claude Code. API-only billing is also available: Sonnet 4.6 at $3/$15 per million tokens, Opus 4.8 at $5/$25, Haiku 4.5 at $1/$5. Most individual developers get the best value from Max 5x at $100/month.

Full pricing breakdown and which tier fits which user below.

Claude Code pricing in 2026 is structured around two paths: subscription plans (Pro, Max, Team) that include Claude Code with usage caps, and API-only access where you pay Anthropic per token used. Most users choose a subscription. Heavy enterprise users sometimes choose the API path, and some use both.

This guide breaks down what each tier actually costs, what you get, and which path makes sense for which kind of user. The price ceiling sits at the Max $200/month plan for individuals, and at custom enterprise contracts above that.

Claude Code Subscription Plans (2026)

Claude Code pricing: model cost breakdown (June 2026)

Model	Input $/MTok	Output $/MTok	Context	Best for in Claude Code
Claude Fable 5	$10	$50	1M tokens	Most demanding reasoning, maximum capability
Claude Opus 4.8	$5	$25	1M tokens	Complex refactors, long-horizon agentic coding
Claude Sonnet 4.6	$3	$15	1M tokens	Daily development — best cost/capability ratio
Claude Haiku 4.5	$1	$5	200k tokens	Fast lookups, simple completions, cost control

Prices from platform.claude.com as of June 10, 2026. Batch API reduces costs by 50%. Prompt caching can reduce input costs significantly for repeated context. Claude Code bills through your Anthropic API account.

Claude Code subscription vs API billing

Option	How billed	Best for
Claude Max plan	Flat monthly ($100 or $200)	Heavy daily Claude Code users who want predictable costs
API pay-as-you-go	Per token used	Variable usage, cost-optimized workflows, teams
API with caching	Per token (cached inputs discounted)	Long system prompts or repeated context (e.g., large codebase)

Anthropic offers four consumer-facing tiers that include Claude Code:

Plan	Price	Best For
Free	$0	Trying Claude in the browser; not Claude Code
Pro	$20/month ($17/month annual)	Light Claude Code use; focused coding sessions
Max 5x	$100/month (monthly only)	Daily Claude Code users; solo devs and operators
Max 20x	$200/month (monthly only)	Heavy users; multi-agent workflows; long sessions
Team Standard	$25/seat/mo ($20 annual, 5-seat minimum)	Small teams; collaboration but NO Claude Code access
Team Premium	$100/seat/month (annual, 5-seat minimum)	Engineering teams; required for Claude Code on Team plans
Enterprise	Custom	Larger orgs with security/compliance needs

Critical note for Team customers: Team Standard does NOT include Claude Code. You need Team Premium seats ($100/seat annual, $125/seat monthly) for any developer who needs Claude Code access. You can mix Standard and Premium seats on one team — useful when only part of your org codes.

What Each Tier Actually Includes

Pro: $20/month

Pro gives you access to Claude.ai (the chat interface), Claude Desktop, and Claude Code via the CLI. Usage limits are tighter than most committed users prefer — running multi-file refactors or long agent sessions hits the cap quickly. Pro is reasonable as a starting point. It is not adequate for serious daily Claude Code work.

Max 5x: $100/month

The 5x designation refers to the rough multiplier on usage limits compared to Pro. For most individual developers who use Claude Code several hours per day, this tier provides enough headroom to work without running into limits constantly. It is the sweet spot for solo operators and small consultancies.

Max 20x: $200/month

20x headroom for users who run Claude Code as an always-on agent — overnight jobs, batch processing, multi-hour orchestration. If you find yourself routinely worried about hitting limits on the 5x tier, the 20x tier removes that worry.

Team Standard: $20-25/seat/month (5-seat minimum)

Team Standard gives a small group shared admin, SSO, SCIM, shared projects, usage analytics, and centralized billing. It is collaboration infrastructure. Crucially, Team Standard does not include Claude Code access — any developer who needs Claude Code must be on a Premium seat.

Team Premium: $100-125/seat/month (5-seat minimum)

Team Premium adds Claude Code to the Team Standard feature set. At $100/seat annual, the per-seat economics match individual Max 5x ($100/month) while adding team management. For an engineering team of 5+ developers using Claude Code daily, Team Premium is a straight upgrade over individual Max subscriptions. You can mix Standard and Premium seats on one team — non-coding teammates can sit on Standard while developers get Premium.

Claude Code via API: Pay-Per-Token

The alternative to a subscription is using Claude Code with API credentials directly. You provide an Anthropic API key, and your token usage gets billed against your Anthropic account at API rates.

API pricing (per million tokens, May 2026 standard rates):

Claude Haiku 4.5: $1.00 input / $5.00 output — cheapest current-generation model, ideal for classification, routing, summarization at volume
Claude Sonnet 4.6: $3.00 input / $15.00 output — best price-to-quality ratio; the production default
Claude Opus 4.8: $5.00 input / $25.00 output — current flagship; complex reasoning and agentic coding
Prompt caching: cached reads at 10% of standard input rate — up to 90% savings on repeated context
Batch API: 50% off both input and output if you can wait up to 24 hours for results
Output:input ratio: consistently 5x across all current-generation models

One catch with Opus 4.8: list price is identical to Opus 4.8, but Anthropic shipped a new tokenizer that can produce up to 35% more tokens for the same input text. Your effective bill per request can go up even though the rate card did not. Worth knowing before you switch your default model.

Always check anthropic.com/pricing for current rates — these change.

For heavy users, the API path can be cheaper than Max, but you give up the predictability of a flat monthly fee. For lighter users, the API path is almost always more expensive than Pro.

How to Decide: Subscription vs API

The decision tree is simpler than it looks.

You use Claude Code less than an hour a day: Pro at $20/month.
You use Claude Code several hours a day: Max 5x at $100/month.
You run Claude Code as an unattended agent or for batch work: Max 20x at $200/month, or API with prompt caching enabled.
You’re a team of 5+ developers: Team Premium at $100/seat/month (annual; $125 monthly), or look at Enterprise.
You have unpredictable spikes: API with budget alerts gives you the most control.

What’s Not Included in Subscription Plans

Even on Max 20x, a few things still cost extra or fall outside the standard plan:

Anthropic API tokens for non-Claude Code use: If you build apps that call the Anthropic API directly, those tokens bill against API credits, not your Max subscription.
Third-party MCP servers with their own costs: Many MCP servers are free, but some integrate with paid services that bill you separately.
Storage and infrastructure costs: Where you actually run Claude Code (your laptop, your cloud VM) still costs whatever it costs.

Hidden Value: Why Max Pays Back Quickly

$100/month sounds steep until you compare it to what Claude Code replaces. For an operator running multi-step content workflows, infrastructure automation, or coding tasks that would otherwise require additional contracting hours, the Max plan typically pays back inside the first week of the month.

One concrete example: drafting and publishing a single SEO-optimized WordPress article with full schema, taxonomy, internal linking, and AEO/GEO optimization takes a human content team 3-5 hours. Running it through a Claude Code pipeline takes 15 minutes of supervised work. The output quality difference is small; the cost difference is large.

This is the framing that matters: Claude Code pricing is not “how much does the AI cost.” It is “how much labor does the AI replace.” On that framing, Max 5x is the cheapest line item in most knowledge-work budgets.

Annual vs Monthly Billing

Anthropic offers a discount for annual prepayment on Pro and Max tiers — generally around 20% off. If you are confident in your usage pattern, the annual prepay is the right call. If you are still evaluating, monthly gives you flexibility to change tiers as your needs shift.

New for June 15, 2026: the Agent SDK Credit Pool (Dual-Bucket Billing)

Starting June 15, 2026, Anthropic splits subscription usage into two buckets: interactive Claude Code sessions keep drawing from your normal plan limits, while unattended Agent SDK work (claude -p, cron jobs, CI pipelines, scripts) draws from a new monthly credit pool — Pro $20, Max 5x $100, Max 20x $200, Team Standard $20/seat, Team Premium $100/seat — with overage billed at standard API rates.

Practical impact: if you run any headless automation on a subscription today, that usage stops counting against your interactive limits and starts metering against the credit pool. Light automation — a nightly script or two — fits comfortably inside Pro’s $20 pool; sustained agent fleets will spill into API-rate overage, at which point a dedicated API key is usually easier to manage. Full mechanics, worked examples, and what to do before the cutover: Claude Agent SDK dual-bucket billing — what changes June 15, 2026. To model your own numbers, use the interactive calculator on our main Claude pricing page.

Frequently Asked Questions

How much does Claude Code cost per month?

Claude Code is included with Claude Pro ($20/month), Max 5x ($100/month), or Max 20x ($200/month). API-only usage is billed per token at separate rates.

Is there a free version of Claude Code?

No. Claude Code requires either a paid Claude subscription (Pro, Max, or Team) or API credentials with a funded account. The Claude free tier does not include Claude Code.

What’s the difference between Max 5x and Max 20x?

The numbers refer to roughly how much usage you get relative to Pro. Max 5x ($100/month) suits daily developers. Max 20x ($200/month) suits heavy users running agent workflows or long batch jobs.

Can I use Claude Code with just an API key instead of a subscription?

Yes. Claude Code accepts an Anthropic API key for authentication. You pay per-token usage at API rates instead of a flat subscription fee.

Is Claude Code cheaper than GitHub Copilot or Cursor?

At the entry level, Copilot ($10/month) and Cursor Pro ($20/month) cost less than Max. Per unit of output for serious work, Claude Code on Max often comes out cheaper because of how much it can do per session.

Does Team pricing include Claude Code?

Only Team Premium ($100/seat annual, $125/seat monthly, 5-seat minimum) includes Claude Code. Team Standard does NOT include Claude Code. You can mix Standard and Premium seats on the same team so non-coding teammates can sit on Standard while developers get Premium.

What happens if I hit my Claude Code usage limit?

On Pro and Max, Claude Code slows or pauses until your usage window resets (typically rolling 5-hour windows on Pro, longer reset cadences on Max). You can upgrade tiers anytime for immediate additional capacity.

The Bottom Line on Claude Code Pricing

For most serious users: Max 5x at $100/month. For light users: Pro at $20/month. For heavy agent workloads: Max 20x at $200/month or API with prompt caching. The pricing is competitive with other AI coding tools, and the value relative to labor it replaces makes Max the cheapest line item on most knowledge-work budgets.

Claude Code API and Model Questions

How much does Claude Code cost in 2026?

Claude Code bills through your Anthropic API account based on which model you use. As of June 2026: Claude Opus 4.8 costs $5/$25 per million input/output tokens; Claude Sonnet 4.6 costs $3/$15 per MTok; Claude Haiku 4.5 costs $1/$5 per MTok; Claude Fable 5 (the new June 2026 flagship) costs $10/$50 per MTok. There is no separate Claude Code subscription — usage is API-billed. Heavy users may find the Claude Max plan ($100–$200/month flat) more cost-effective.

What is the cheapest way to use Claude Code?

Use Claude Haiku 4.5 ($1/$5 per MTok) for simple tasks and Claude Sonnet 4.6 ($3/$15 per MTok) for most development work. Enable prompt caching for large codebases — repeated context (like a long system prompt or frequently referenced file) is cached and billed at a significant discount. Use the Message Batches API for non-real-time work to get 50% off standard rates. Reserve Opus 4.8 or Fable 5 for tasks that genuinely require maximum capability.

Does Claude Code have a subscription plan?

Claude Code itself does not have its own subscription — it bills through your Anthropic API account. However, the Claude Max plan ($100/month for 5x usage limits, or $200/month for 20x limits) can cover Claude Code usage. If you’re using Claude Code heavily every day, Max may be more cost-effective than pure pay-as-you-go API billing. Check platform.claude.com/docs/en/about-claude/pricing for current plan details.

Which Claude model should I use with Claude Code?

Claude Sonnet 4.6 is the best default for most Claude Code workflows — it offers near-Opus intelligence at half the price ($3 vs $5 per input MTok) and supports extended thinking. Use Claude Opus 4.8 for complex multi-file refactors or architecturally difficult problems where output quality is worth the premium. Claude Fable 5 (launched June 10, 2026) is available for maximum capability tasks. Use Haiku 4.5 for fast, cheap lookups and simple completions.

Does Claude Code support prompt caching?

Yes. Claude Code supports Anthropic’s prompt caching feature. For workflows where you repeatedly pass the same large context — a codebase system prompt, a long CLAUDE.md file, frequently referenced documentation — prompt caching stores that context and bills repeated reads at a discounted rate. This can significantly reduce costs for projects with large persistent context. See platform.claude.com/docs/en/build-with-claude/prompt-caching for implementation details.

How do I track my Claude Code API spending?

Monitor usage at platform.claude.com — the console shows token usage and cost by model, date range, and API key. Set spending limits on your API key to cap maximum monthly spend. For teams, use separate API keys per project or environment to attribute costs. The usage dashboard updates in near-real time so you can catch runaway spend before it compounds.

📖 Related Claude Guides

May 25, 2026

The Rise of the Curation Class — and the case that it’s already running on Notion, Claude, and GCP
A Second Take on The Rise of the Curation Class, published here yesterday. The original named a demographic. This one names the working architecture underneath it — and argues that for solo operators willing to assemble the substrate, the Curation Class is not an emerging future. It is a present tense.

The Thesis from the Source Post

The original piece described a newly emerging demographic — the Curation Class — defined by its rejection of mass-produced goods in favor of personalized, bespoke experiences. Unlike the mass-luxury class that hired professionals to curate taste for them, the Curation Class authors its own taste. It uses interconnected ecosystems to make personal authorship coherent and reproducible across time.

Five technological signatures distinguish them:
- They value the interconnected ecosystem over the device. The phone, the ring, the wearable — these are access tokens. The ecosystem is what the tokens unlock.
- They want invisible, frictionless interfaces. When the ecosystem works, it disappears. They will pay a premium for the subtraction of friction.
- They use AI as an instrument, not a replacement — to make their own decisions legible and reproducible, to check their work against their own internal standards.
- They demand a user-owned Second Brain — a persistent personal memory layer that crosses contexts, owned by them, not by a vendor.
- They require hyper-personalized verification — relationships and protocols specifically tuned to them, verified, traceable, theirs.
The source frames this as a consumer emergence — luxury tech for the post-luxury class.

That frame is correct as far as it goes.

This is the case that it does not go far enough.

The Second Take

The Curation Class is not a demographic waiting to be served by better consumer products. It is a working operating model. The people the source describes are not waiting for a wearable to ship. Many of them already have the stack. They built it themselves out of components that do not, in any obvious way, look like luxury goods.

The substrate is not titanium and cashmere. It is Notion, Claude, and Google Cloud Platform, wired together with a small number of disciplined patterns.

This is not a hypothetical. It is what Tygart Media runs on. The same five signatures the source identified — ecosystem over device, invisible interface, AI as instrument, user-owned Second Brain, hyper-personalized verification — are present in the production system that publishes this article. They are not aspirational. They have names, IDs, deployment dates, and gate-failure logs.

What follows is the architecture. Not as a brag. As a working diagram of what the Curation Class looks like when you build it instead of buying it.

1. The Two-Plane Architecture — Ecosystem Over Device

The canonical architecture has two planes and a brain.
- Notion is the Control Plane — the warehouse and the face. It holds every spec, every database, every Work Order, every Promotion Ledger row, the entire Second Brain. The operator owns it 100%. Notion stores and surfaces. Notion does not think.
- Google Cloud Platform is the Compute Plane — the plumbing. Cloud Run executes the workers. Cloud Scheduler triggers them. Workload Identity Federation authenticates them without stored keys. The operation’s technical partner owns it 100%. The compute is inside a VPC the operator owns.
Then there is the brain.

Claude is the brain. Not a plane. Not a leg of the stool. The operator’s instrument. Specifically: Claude Code on the laptop for heavy execution — file ops, deployments, multi-step agentic work, Work Order drafting, reading from and writing to the warehouse — and Claude chat on mobile for orchestration, thinking, captures, on-the-go decisions, and conversational architecture sessions. The brain operates outside the warehouse and dispatches work into both planes.

The handoff between planes is a structured artifact called a Work Order. The operator, working through Claude, decides that a new capability is needed. Claude drafts a Work Order in Notion that specifies what the capability does, what triggers it, what it reports back. The compute-plane operator reads the Work Order, designs the GCP implementation, builds the Cloud Run service, and wires the trigger so the warehouse can fire it directly. The Promotion Ledger logs the new behavior and starts its seven-day clean-day clock.

This is the Curation Class’s first signature made literal. The value is not in any one tool. Notion alone is a planner. GCP alone is a hyperscaler. Claude alone is a chatbot. Wired together with the operator and the compute partner each owning one plane and the brain moving freely between them, they are an ecosystem. The operator does not stare at any one screen. The operator stares at outcomes.

The device, in this frame, is whatever the operator happens to be holding. The laptop runs Claude Code. The phone runs Claude chat. The warehouse runs in a browser tab. The plumbing runs in a region the operator never visits. The ecosystem is the architecture.

A real production note worth surfacing here: this architecture is recent. The operation tested an earlier version that put the brain inside Notion — Notion AI as orchestrator, Notion Workers as the thinking layer. The quality ceiling was too low. Notion AI is excellent at retrieval and at acting on the warehouse from inside it. Its reasoning and orchestration quality lagged the frontier models accessed natively. The doctrine update happened in the last twenty-four hours. The brain moved back outside. Claude Code on laptop and Claude chat on mobile became canonical. This is the kind of decision the Curation Class actually makes — not picking the integrated all-in-one solution because it is convenient, but picking the right tool for each plane and accepting the cost of wiring them together.

2. The Promotion Ledger and the Tier Ladder — AI as Instrument, Not Replacement

This is where the source post stops gesturing and the working system has to commit. The Curation Class wants AI that checks its work against its own internal standards. Fine. What does that look like in production?

It looks like a Promotion Ledger.

Every autonomous behavior in the system — every scheduled worker, every published post, every Slack alert — is logged on a Notion database called the Promotion Ledger. Each behavior has a row. Each row has a Tier and a Status.

The tiers run A through C with a Wings designation above:
- Tier A behaviors propose. The system writes a draft, builds a report, surfaces a recommendation. The operator approves via an elevated report — not an atomic per-task confirmation, but a periodic sign-off on a batch. Nothing publishes without approval.
- Tier B behaviors prepare. The system stages the work — drafts written, images generated, schemas built, social drafts queued. The operator flies the plane. The system does the ground crew job.
- Tier C behaviors run. The system publishes without per-task approval. The operator only sees the work if it fails a gate. Tier C is autonomy.
- Wings is the graduated state. A behavior that has run clean at Tier C long enough to be considered structurally trusted.
The ladder is governed by a seven-day clean-day clock. Seven consecutive clean days at a tier — no gate failures, no anomalies, no operator overrides — and the behavior becomes a candidate for promotion. Promotion decisions happen on Sundays. Nothing gets bumped up mid-week.

Failure runs in the opposite direction. A gate failure resets the clean-day clock on that behavior and drops it one tier. The failure is logged with date and reason. The Slack alert points to the row.

This is the structural answer to the Curation Class’s demand for AI that does not replace the operator’s judgment. The system does not improvise trust. Trust is earned by running clean for measurable, public, auditable periods. The operator is not asked to feel confident. The operator is asked to look at the Promotion Ledger.

The Pane of Glass is the live view of the ledger — a single artifact, surfaced in the Cowork workspace, that shows every behavior, its tier, its status, its clean-day count, and the date of its last gate failure if any. It is the dashboard the source post’s Curation Class would recognize. It is also the dashboard a regulator would recognize. Same mechanism. Both audiences served by the same artifact.

The deeper move here is linguistic. The system reports in tiers, not in reassurance. The output of a Tier C behavior is not “Three drafts are ready for your review.” The output is “Three posts published. No anomalies.” The operator does not approve every action. The operator audits the ledger.

This is what AI-as-instrument looks like when you stop saying it and start measuring it.

3. The Context Index and claude_delta — A Second Brain That Stays Legible

The Curation Class wants a persistent memory layer that crosses contexts. Wellness data talks to work schedules. Home environments talk to project files. Disconnected parts of life communicate.

The operational challenge nobody in the consumer pitch ever names is this: any sufficiently large personal knowledge graph hits a context window ceiling. AI models have token limits. A real Second Brain, after a year of accumulation, will not fit in one fetch.

The Tygart Media answer is the Context Index, sharded.

The origin story is unglamorous. The Context Index started as a single Notion page — every important fact about the operation, every credential reference, every architectural decision, every key relationship. At 170 kilobytes of dense Notion markdown, it exceeded the practical fetch ceiling for any model session. Loading it consumed most of the available context before the actual work could begin.

The fix was structural. The 170KB page was sharded into a 6.5KB router and six domain-scoped shard pages. The router holds the index — what each shard contains, which shard to fetch for which task. The shards hold the depth. A session fetches the router first, decides which shards it actually needs, and pulls only those. The router is cheap. The shards are demand-loaded.

The second layer is claude_delta — a JSON metadata block placed at the top of every Notion page in the system. Version 1.0 specifies a small set of fields: page type, related entities, schema references, source post links, status. It is the airport-codes layer of the Second Brain. A model session can scan the delta block and know, in three hundred bytes, whether the page is worth fetching in full.

This is what user-owned memory at scale actually requires. Not the warm assurance that your data is yours. The unglamorous engineering that makes your data fetchable by your own tools at the speeds your work demands. The Curation Class’s Second Brain is not a marketing promise. It is a routing problem solved by router-and-shard architecture and a metadata standard.

The data lives in Notion. The brain that reads it lives in the operator’s own Claude sessions — Code on the laptop, chat on the phone. The compute that runs it lives in the operator’s GCP project. No vendor between the operator and the operator’s own memory.

4. The Fortress Architecture — Hyper-Personalized Verification With Sovereignty Intact

The source post lands on a Concierge Cred Network — the ecosystem verifies the specific barista who knows the exact coffee temperature, the specific protocols tuned to the specific body. Verification is the move. The Curation Class trusts individuals and protocols, not brands.

The security counter-argument is the part the consumer framing glosses. Hyper-personalized verification means a lot of sensitive data flowing through a lot of vendors. Wellness, schedule, location, biometrics, relationships. Every one of those data streams is a vector for surveillance, breach, and lock-in.

The Tygart Media posture is Fortress Architecture. The principle is one sentence: AI connects to WordPress from inside a GCP VPC, not via outbound plugins.

Most AI integrations are sold as plugins. You install something on your WordPress site, the plugin reaches outward to an AI vendor’s API, the vendor sees your content, your traffic patterns, your user data. Convenient. Also a permanent surveillance line into your operation.

The Fortress flips the direction. WordPress runs on a Compute Engine VM inside a VPC the operator owns. The AI tools that act on it — the publishing workers, the schema injectors, the content quality gates — run in the same VPC, on Cloud Run, authenticating with Workload Identity Federation. They reach in over the private network. WordPress is not exposed to the AI vendor. The AI vendor is not even on the path.

The operator’s content, credentials, and customer data stay inside the operator’s perimeter. The Curation Class’s demand for sovereignty is not a feature toggle. It is a network topology choice.

This is the part the consumer narrative cannot land because it would require admitting that most consumer AI is sold by entities whose business model conflicts with the customer’s stated values. The Fortress is the working answer. You do not need to trust the vendor. You need to architect a perimeter in which the vendor does not have standing.

5. The Soda Machine Thesis — The Complete Mental Model

The pieces above are mechanisms. The mental model that holds them together is the Soda Machine Thesis.

The thesis treats a personal Notion workspace not as a productivity app but as an operating company.
- Notion is the building. The physical structure inside which the company operates.
- Databases are the floors. Master Actions, Content Pipeline, Knowledge Lab, Promotion Ledger — each is a department occupying a floor.
- The operator is the Owner. Holds equity, sets strategy, signs off on capital decisions. Does not pour the concrete or run the daily standups.
- AI-in-conversation is the Architect. Sits at the table when the building’s structure is being decided. Reviews plans, flags structural issues, drafts elevations. Does not, however, frame the walls.
- Custom Agents are the General Contractors. Domain-specific instances of AI with bounded scopes and named responsibilities — the GC for content, the GC for social, the GC for client reporting. They manage the trades and report up.
- Workers are the subcontractors. Cloud Run jobs, Cloudflare Workers, scheduled scripts. They do the actual labor on the actual floor. They show up, do the work, file the report, leave.
The Soda Machine name comes from the simplest version of the metaphor. A soda machine is a fully self-contained business — it sells product, collects revenue, restocks itself, calls for service when it breaks. It does not need a human in the loop for the routine. It needs an operator at the top who decided to put it there.

This is the model that makes the Promotion Ledger coherent. The Tier C behaviors are soda machines. The Tier A behaviors are GCs proposing new construction. The operator is not the construction worker. The operator is not even the foreman. The operator is the one who decides which buildings to put up and which floors to add.

The Curation Class signature this resolves is the deepest one — the demand to design one’s own life and have the design hold across years. The Soda Machine Thesis gives the language for what kind of structure the design is. Not a workflow. Not a productivity system. A holding company, with a portfolio, with trades, with audits.

6. The Human Substrate — Why This Particular Ledger

A working system carries the fingerprints of the person who built it. The Promotion Ledger is no exception.

The ledger’s seven-day clean-day rule and three-tier trust architecture are not abstract design choices. They trace back to a childhood sorting mechanism — an only child in a military family, moving every two or three years, developing a way to decide what to keep, what to demote to storage, and what to throw out. The decision was always tiered. Always conditional on a clock. Always documented, even if only to himself, because the next move was always coming and the calculus had to survive the move.

The Promotion Ledger is that calculus made operational. Behaviors graduate the way belongings did. Behaviors fail the way belongings did when the next move proved them dead weight. The seven-day clock is the operational version of “if I haven’t touched this since the last move, it does not move with me.”

This matters because the Curation Class signature the source post identifies — the demand for hyper-personalized verification, for relationships and protocols specifically tuned to the operator — only holds if the operator’s tools carry the operator’s actual cognitive fingerprint. A Promotion Ledger written by someone else, even a perfect one, would not be this one. The childhood-sorting origin is what makes it legible to its operator. It also is what makes it defensible — when a gate fails and the system demotes a behavior, the operator does not argue with it. The mechanism is older than the system.

This is the human substrate the consumer pitch cannot reach. The bespoke AR ring is bespoke in finish. The Promotion Ledger is bespoke in mechanism. One is a luxury good. The other is an operating system.

The Curation Class Is Already Here

The source post described a class waiting for an ecosystem to ship. The honest read is that the ecosystem is shippable today, from components most operators already have access to, if they are willing to do the work of wiring them together with discipline.

Notion accounts exist. Claude subscriptions exist. GCP free tiers are generous enough to run a real operation on. The two-plane architecture with Claude as the brain is a deployment pattern, not a luxury product. The Promotion Ledger is a Notion database with a Tier column and a Status column and a clean-day counter — the schema is not the hard part. The hard part is the operator’s willingness to publish on Tier C without manual review, to let the ledger be the source of truth, to read “three posts published, no anomalies” as the success state instead of asking for the drafts.

That willingness is what the Curation Class actually demands of its members. Not money. Not titanium. The discipline to design a system that runs without you, and then to trust the audit trail when it does.

The consumer version of the Curation Class will eventually ship. There will be expensive rings and curated concierge networks and verified protocols, and the people who can afford them will own them, and the people who sell them will collect the margin.

The operator version is already running.

It looks like a Notion workspace with a Promotion Ledger pinned to the top, a GCP project running quietly inside a VPC nobody else has standing in, Claude Code open on a laptop and Claude chat on a phone, and a person on the other end of the system who does not stare at any one screen because the screens are not the point.

The ecosystem is the point.

And it disappeared a while ago.
May 18, 2026
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
May 17, 2026

How do I get an Anthropic API key?

Is there a free tier for the Anthropic API?

How much does the Anthropic API cost?

How do I keep my Anthropic API key secure?

What happens if my Anthropic API key is compromised?

Can I use my Anthropic API key with Claude Code and Claude Cowork?

Is Claude Code free?

What is the cheapest plan that includes Claude Code?

Does Claude Code use API tokens from my subscription?

How does Claude Code pricing compare to GitHub Copilot?

Can I use Claude Code on a Team Standard plan?

What happens to Claude Code usage when I hit my plan limit?

How much does Claude Code cost in 2026?

What is the cheapest way to use Claude Code?

Does Claude Code have a subscription plan?

Which Claude model should I use with Claude Code?

Does Claude Code support prompt caching?

How do I track my Claude Code API spending?

📖 Related Claude Guides

Tag: Claude

1. The Physics of the Whiteboard

2. The Haiku Trick: Precision Over Power

3. The Formula One Mindset: Strategy Outruns Raw Compute

4. What Agents Teach Us About Human Momentum

5. The Internalized Hybrid

Conclusion: Getting Back in the Seat

The Architecture of Delegation: Moving Beyond the Chat Interface

Quantifying the Backlog and the Taxonomy Threat

The Pilot Test and the Strict JSON Constraint

Scaling Up: Hitting the Windows Bottlenecks

The Verdict: The Orchestrator vs. The Worker

Tomorrow’s Takeaway

The Economics of Cognitive Budget

The Tygart Media Benchmark: 1,000 Posts and 931 Tags

Defining the Bounded Subtask

The Marginal Zero: Subscription Arbitrage

Architectural Resilience and Multi-Vendor Strategy

What You Should Do Tomorrow

What Anthropic actually did

The new numbers, by plan

What this changes about plan selection

The hidden costs that didn’t change

What to do this week

The model versions to use

Claude Code Plan Mode vs Auto Mode: When to Use Each

What Plan Mode Actually Does

How to Enable Plan Mode

When Plan Mode Pays Off

When Plan Mode Gets In the Way

Working Inside the Plan

What Plan Mode Does Not Protect Against

Plan Mode vs Other Safety Patterns

A Working Habit

Frequently Asked Questions

What is Plan Mode in Claude Code?

How do I enable Plan Mode in Claude Code?

When should I use Plan Mode?

Does Plan Mode make Claude Code slower?

Can I edit the plan before approving it?

Is Plan Mode the same as a sandbox?

What’s the difference between Plan Mode and per-tool permissions?

The Bottom Line

Why Routing Matters in the First Place

Anthropic’s Built-In Claude Code Routing

Manual Model Selection: The 80/20 Approach

Third-Party Claude Code Routers

OpenRouter and Multi-Provider Routers

Custom In-House Routers

Routing Rules That Actually Work

What Anthropic Does Not Yet Ship

Costs: What Routing Actually Saves

When Not to Build a Router

Frequently Asked Questions

What is a Claude Code router?

Does Claude Code have built-in routing?

What’s the difference between OpenRouter and a custom router?

Should I use OpenRouter with Claude Code?

How do I pick the right Claude model for a task?

How much can routing save me?

Is there a cost to routing through OpenRouter?

The Bottom Line

Anthropic API Pricing Tiers (June 2026)

What an Anthropic API Key Is (and Isn’t)

Creating a key (the short version)

Adding Billing Before You Can Use the Key

Anthropic API Key Format

Which Claude Models the API Key Works With

How to Use the API Key

Security: How to Not Leak Your Key

Rotating an Anthropic API Key

Workspace and Organization Keys

Monitoring API Key Usage

Frequently Asked Questions

How do I get an Anthropic API key?

Is the Anthropic API key free?

Does my Claude Pro or Max subscription include API credits?

What does an Anthropic API key start with?

What happens if my Anthropic API key gets leaked?

Can I use the same API key for Claude Code and my own app?

3. The Context Index and `claude_delta` — A Second Brain That Stays Legible