Tag: Claude

  • Claude Opus 4.8 Feature Deep Dive: Context, Extended Thinking & Task Budgets (2026)

    Claude Opus 4.8 Feature Deep Dive: Context, Extended Thinking & Task Budgets (2026)

    Last refreshed: June 9, 2026

    Model Accuracy Note — Updated June 9, 2026

    Current flagship: Claude Opus 4.8 (claude-opus-4-8). Current models: Opus 4.8 · Sonnet 4.6 · Haiku 4.5. Claude Opus 4.8 (claude-opus-4-8) is the current flagship as of April 16, 2026. Where this article references Opus 4.6 or earlier models, those references are historical. See current model tracker →. See current model tracker →

    Claude Opus 4.8 Key Features (June 2026)

    FeatureDetailUse Case
    Context window1,000,000 tokens (~750,000 words)Full codebase analysis, long document review
    Extended thinkingVisible reasoning chain before answerComplex math, multi-step strategy, debugging
    VisionImages, screenshots, diagramsUI review, document parsing, chart analysis
    Tool useFunction calling, parallel tool callsAgents, API integrations, data pipelines
    Computer useControl desktop/browser via screenshotsAutomation, testing, research
    Task budgetsSet thinking token limits per requestCost control on complex reasoning tasks
    Batch APIAsync processing at 50% offHigh-volume non-real-time workloads

    What this article covers

    Three features in Opus 4.8 deserve their own explanation because they change what’s actually possible in daily work, not just what’s bigger on a benchmark chart:

    1. Task budgets (beta) — per-subtask ceilings that tame agent cost variance.
    2. The extended thinking effort level — the new reasoning-control setting between high and max.
    3. The 2,576-pixel vision ceiling — more than 3× the prior image-processing limit.

    Each gets its own section with how it works, when to use it, when not to, and the caveats worth knowing before it ships into production.


    Feature 1: Task budgets (beta)

    Four gates: max turns, tool allowlist, token budget, kill switch
    Feature 1 — task budgets (beta).

    What it is. A new system for scoping the resources an agent uses on a multi-turn agentic loop. Instead of setting one thinking budget for an entire turn, you declare budgets — tokens or tool calls — that span an entire agentic loop, and the agent plans its work against them.

    The problem it solves. Agent runs have notoriously high cost variance. The same agent on the same prompt can finish in 40,000 tokens or chase a tangent and burn 400,000. Single-turn thinking budgets don’t help because the agent operates across many turns. Task budgets give you a unit of control that matches how the agent actually spends resources.

    How the agent uses them. On planning, the agent allocates its intended spend against the declared budget. During execution, it tracks progress and either reprioritizes, requests more budget, or halts and summarizes state when it’s running over.

    Behavior note: budgets are soft, not hard. The agent is nudged to respect them, not hard-cut. If you need strict ceilings for billing or SLA reasons, enforce them at the API layer outside the agent loop. Task budgets are for behavior shaping, not hard resource limiting.

    When to use them.
    – Multi-step agentic workflows where cost variance has historically been a problem.
    – Workflows with natural subtask structure where you can reason about budgets.
    – Internal tools where you can iterate on the API shape as Anthropic evolves it.

    When not to use them.
    – Simple single-turn requests. Task budgets are overhead that doesn’t pay off on short interactions.
    – Production contracts that are painful to version. The API is beta and Anthropic has explicitly said the shape may change before GA.
    – Workflows where you need provable hard cutoffs. Enforce those at the API layer, not via this feature.

    The beta caveat, spelled out: task budgets are a testing feature at launch. Parameter names and shape may change. Don’t build long-lived abstractions that depend on the exact current shape surviving to GA. Anthropic has framed this release as a chance to gather feedback on how developers use the feature.


    Feature 2: The extended thinking effort level

    Three-column board mapping Claude model seats to flagship thinking, production workhorse, and fast volume jobs
    Feature 2 — the extended thinking effort level.

    What it is. A new setting for reasoning effort, slotted between high and max. Opus 4.6 had three levels: low, medium, high. Opus 4.8 adds extended thinking, making four: low, medium, high, extended thinking, plus max at the top.

    Why it exists. Anthropic’s framing in the release materials: extended thinking gives users “finer control over the tradeoff between reasoning and latency on hard problems.” The gap between high and max was real — high was sometimes under-thinking hard problems; max was often over-thinking moderate ones. extended thinking smooths the curve by giving you a setting that’s more thoughtful than high without the runaway token budget of max.

    Anthropic’s own guidance. “When testing Opus 4.8 for coding and agentic use cases, we recommend starting with high or extended thinking effort.” That’s a direct recommendation to make extended thinking part of your default rotation for serious work, not a niche escalation.

    How to use it.
    – Keep high as the default for routine work.
    – Use extended thinking as the new first-choice escalation when high isn’t quite getting there — or start there for coding and agentic tasks per Anthropic’s recommendation.
    – Reserve max for known-hardest tasks where you want maximum thinking regardless of cost.

    Important tradeoff. Higher effort levels in 4.7 produce more output tokens than the same levels did in 4.6. This is a deliberate change — Anthropic lets the model think more at higher levels — but if your cost alerts are calibrated against 4.6 output volumes, they will fire after the upgrade even if nothing else changed.

    An API note worth flagging. Opus 4.8 removed the extended thinking budget parameter that existed in 4.6. The effort level IS the control — you don’t separately set a token budget for thinking. If your 4.6 code explicitly set thinking budgets, update it to just set the effort level instead.

    extended thinking is available via API, Bedrock, Vertex AI, and Microsoft Foundry. On Claude.ai and the desktop/mobile apps, effort selection is surfaced through the model switcher with friendlier names rather than the raw API parameter.


    Feature 3: The 2,576-pixel vision ceiling

    What changed. Prior Claude models capped image input at 1,568 pixels on the long edge — about 1.15 megapixels. Opus 4.8 processes images up to 2,576 pixels on the long edge — about 3.75 megapixels, more than 3× the prior pixel budget.

    Why this matters more than it sounds. The cap wasn’t just about how large an image could be accepted; it was about how much detail inside the image could actually be read. Under the old 1.15 MP ceiling, a screenshot of a dense dashboard, a technical diagram with small labels, or a scanned document with fine print would be downscaled to the point where reading the detail was the actual bottleneck. 4.7 removes that bottleneck for images up to the new ceiling.

    Coordinate mapping is now 1:1. This is a separate but related change. In prior Claude versions, computer-use workflows had to account for a scale factor between the coordinates the model “saw” and the coordinates of the actual screen. On Opus 4.8, the model’s coordinate output maps 1:1 to actual image pixels. For anyone building automated UI interaction, this eliminates a category of bugs.

    What this enables that 4.6 struggled with:

    • Dense UI screenshots. Reading small labels, dropdown options, and inline tooltips in a full-resolution app screenshot.
    • Technical diagrams. Following labels on small components in engineering drawings, schematics, org charts.
    • Scanned documents. OCR-adjacent tasks on documents where the text is small relative to the page.
    • Chart details. Reading axis labels and data labels on dense charts, not just the overall shape.
    • Multi-panel content. Comics, infographics, and documents with small type in multiple zones.
    • Pointing, measuring, counting. Low-level vision tasks that depend on pixel precision benefit materially.
    • Bounding-box detection. Image localization tasks show clear gains.

    What it doesn’t change.

    • Images beyond 2,576px still get downscaled to the ceiling. The ceiling is higher; it’s not gone.
    • Video frames are handled differently and aren’t covered by this change.
    • Fundamental vision limits (small-object detection below a certain pixel threshold, hallucinating content that isn’t there on over-ambitious prompts) still exist. More pixels ≠ omniscience.

    Pricing and token cost. Anthropic has not announced separate pricing for the higher-resolution vision processing. Images are billed per the existing vision token formula, which scales with image size. Larger images cost more tokens; that’s not new. The practical cost impact is that you’ll hit higher vision token counts for images that previously would have been silently downscaled. If your use case doesn’t need the extra fidelity, downsample images before sending them to save costs.

    How to use it.

    Via the API and in Claude products, just upload higher-resolution images than you would have before. No special parameter. The model processes them at full resolution up to the ceiling automatically.

    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {...}},  # up to 2576px long edge
                {"type": "text", "text": "Extract the values from the chart."},
            ],
        }],
    )
    

    A caveat worth noting. The 2,576px ceiling is the processing ceiling. Client-side size limits (file size, API request size) still apply. Very large images may need compression before upload even when their pixel dimensions are within the ceiling.


    How these three features compose

    Three panels showing one problem, three options, one recommendation
    How these three features compose.

    The three features aren’t independent. For agentic coding work in particular, they compose in ways that matter.

    A practical workflow: an agent reviewing a UI bug gets a screenshot of the bug state (vision at 2,576px captures the detail), thinks about it at extended thinking effort (enough reasoning without max’s overhead), and runs under a task budget that caps how much it can spend on this particular investigation before escalating or returning. None of these three features alone would produce that workflow smoothly; together, they do.

    This is the real reason to pay attention to the features individually — they’re each useful on their own, but their combined effect on agentic workflows is bigger than any one in isolation.


    Frequently asked questions

    Are task budgets available on Claude.ai, or API only?
    API only. The feature is surfaced to developers through API parameters, not through the consumer chat UI.

    Can I use extended thinking on Claude.ai?
    Effort level is exposed to consumers through the model switcher. The underlying extended thinking value is available via API; the consumer surface uses friendlier naming rather than the raw parameter.

    Does the vision processing capabilities apply to all Claude products?
    Yes — Claude.ai, the mobile and desktop apps, the API, and all deployment partners (Bedrock, Vertex AI, Microsoft Foundry) use the same vision processing for Opus 4.8.

    Are task budgets a replacement for max_tokens?
    No. max_tokens is a hard cap on output length for a single message. Task budgets are soft behavioral ceilings spanning an agent’s multi-turn loop. Use both.

    Does extended thinking use a different API parameter than high?
    No — it’s just another value for the same effort parameter. Note that Opus 4.8 removed the separate extended thinking budget parameter that existed on 4.6: the effort level IS the thinking control on 4.7.

    Will these features come to Opus 4.6?
    No. They’re Opus 4.8 features. 4.6 continues to run on its prior behavior.

    Does extended thinking cost more than high?
    Yes, indirectly. Per-token pricing is the same. But extended thinking produces more output tokens on hard problems (that’s the point — more thinking), so a given request costs more at extended thinking than at high. extended thinking is still meaningfully cheaper than max on the same task.


    Related reading

    • The full release: Claude Opus 4.8 — Everything New
    • For developers: Opus 4.8 for coding in practice
    • Comparison: Opus 4.8 vs GPT-5.4 vs Gemini 3.1 Pro
    • The Mythos angle: why Anthropic admitted Opus 4.8 is weaker than an unreleased model

    Published April 16, 2026. Article written by Claude Opus 4.8.

    Frequently Asked Questions

    What are the key features of Claude Opus 4.8?

    Claude Opus 4.8 (claude-opus-4-8) is Anthropic’s current flagship model with a 1 million token context window, extended thinking (visible reasoning chain), vision capabilities, tool use with parallel function calling, computer use for desktop automation, and configurable task budgets for cost control on reasoning-heavy tasks. Available via API at $5 input / $25 output per million tokens.

    What is extended thinking in Claude Opus 4.8?

    Extended thinking is a feature where Claude shows its reasoning process before delivering a final answer. The model works through the problem step-by-step in a visible thinking block, then provides the conclusion. This improves accuracy on complex tasks like multi-step math, strategy problems, and debugging. You can set a thinking token budget to control cost.

    How does Claude Opus 4.8’s 1M token context work?

    The 1 million token context window lets Claude Opus 4.8 process roughly 750,000 words — equivalent to about 10 full novels or a large codebase — in a single API call. Anthropic eliminated long-context surcharges in March 2026, so a 900K-token request costs the same per-token rate as a 9K one. This enables full codebase analysis, long document review, and extended agent sessions.

    What is the task budget feature in Claude Opus 4.8?

    Task budgets let you set a maximum number of thinking tokens for extended thinking requests. This gives you cost predictability on complex reasoning tasks. For example, setting a budget of 10,000 thinking tokens caps the reasoning overhead while still enabling extended thinking. Higher budgets generally improve accuracy on harder problems.

    Is Claude Opus 4.8 the best model for computer use?

    Yes, Claude Opus 4.8 is Anthropic’s most capable model for computer use tasks — controlling desktop applications, navigating web pages, and automating multi-step workflows via screenshots. Claude Sonnet 4.6 also supports computer use at lower cost. Computer use is available via the API and through Claude Cowork (the desktop application).

    When should I use Opus 4.8 vs Sonnet 4.6?

    Use Claude Opus 4.8 when task complexity demands the best reasoning: analyzing large codebases, writing complex technical documents, extended agent workflows, or tasks where extended thinking significantly improves output quality. Use Claude Sonnet 4.6 ($3/$15 per MTok, 40% cheaper) for most everyday tasks — writing, coding, analysis — where Opus-level reasoning is not needed.

  • Opus vs GPT-5 vs Gemini Pro: Frontier Benchmarks 2026

    Opus vs GPT-5 vs Gemini Pro: Frontier Benchmarks 2026

    Last refreshed: June 9, 2026

    Model Accuracy Note — Updated June 9, 2026

    Current flagship: Claude Opus 4.8 (claude-opus-4-8). Current models: Opus 4.8 · Sonnet 4.6 · Haiku 4.5. Claude Opus 4.8 (claude-opus-4-8) is the current flagship as of April 16, 2026. Where this article references Opus 4.6 or earlier models, those references are historical. See current model tracker →. See current model tracker →

    Claude Opus 4.8 vs GPT-5 vs Gemini 2.5 Pro: Head-to-Head (June 2026)

    AttributeClaude Opus 4.8GPT-5Gemini 2.5 Pro
    DeveloperAnthropicOpenAIGoogle DeepMind
    API IDclaude-opus-4-8gpt-5gemini-2.5-pro
    Context window1M tokens128K tokens1M tokens
    Input price (per MTok)$5.00$15.00$3.50
    Output price (per MTok)$25.00$75.00$10.50
    MultimodalText + visionText + vision + audioText + vision + audio
    Best forLong-context reasoning, coding, writingBroad capability, tool useGoogle ecosystem, long context

    Prices verified June 9, 2026 from official platform documentation. GPT-5 pricing from platform.openai.com. Gemini 2.5 Pro pricing from ai.google.dev.

    The short verdict

    Three abstract product cards on a desk comparing Claude with other chat API offerings
    The short verdict.
    • Best for agentic coding and long-horizon engineering: Opus 4.8.
    • Best for single-turn function calling and ecosystem breadth: GPT-5.
    • Best for multimodal input volume and long-context retrieval: Gemini 2.5 Pro.
    • Cheapest at the frontier: Gemini 2.5 Pro. Most expensive: GPT-5.
    • If you can only pick one for general knowledge work in June 2026: Opus 4.8.

    The full reasoning is below. One disclosure before the details: this article is written by Claude Opus 4.8. I am one of the models being compared. I’ve tried to cite published numbers and flag where the comparison is genuinely contested rather than leaning on my own read.


    Pricing as of April 16, 2026

    Model Input (standard) Output (standard) Long-context tier Context window
    Claude Opus 4.8 $5 / M tokens $25 / M tokens Same across window 1M tokens
    GPT-5 $5.00 / M tokens $15 / M tokens $5 / $22.50 over 272K 1M tokens (272K before surcharge)
    Gemini 2.5 Pro $2 / M tokens $12 / M tokens $4 / $18 over 200K 1M tokens (some listings cite 2M)

    Takeaways:
    – Gemini 2.5 Pro is the cheapest per token at the frontier — 7.5× cheaper on input than Opus 4.8 and 2× cheaper than GPT-5 at standard context.
    – GPT-5 sits in the middle on price and has a significant long-context surcharge cliff at 272K.
    – Opus 4.8 is the most expensive per token, with no long-context surcharge.
    – All three now have 1M-class context windows, but Opus 4.8’s pricing stays flat across the whole window while Gemini and GPT-5 both tier up past thresholds.

    Tokenizer caveat: Opus 4.8 uses a new tokenizer that produces up to 1.35× more tokens per input than Opus 4.6 did, depending on content type. Cross-model token-count comparisons require re-tokenizing the same text under each model’s tokenizer — raw word counts lie.


    Benchmarks, with the caveats included

    Anthropic, OpenAI, and Google all publish benchmark numbers. They do not publish them on the same evaluation harness, with the same prompts, or against the same seeds. Treat the following as directional, not definitive.

    Agentic coding (long-horizon, multi-file):
    – Opus 4.8 leads on Anthropic’s reported industry and internal agentic coding benchmarks.
    – GPT-5 is competitive on single-turn function calling and tool use. Roughly 80% on SWE-bench Verified at launch.
    – Gemini 2.5 Pro scored 80.6% on SWE-bench Verified at launch — essentially tied with GPT-5.

    Multidisciplinary reasoning (GPQA Diamond and similar):
    – Opus 4.8 leads on Anthropic’s comparisons.
    – GPT-5 and Gemini 2.5 Pro are close. Gemini reports 94.3% on GPQA Diamond.

    Scaled tool use and agentic computer use:
    – Opus 4.8 leads on Anthropic’s reported benchmarks.
    – GPT-5 has a native Computer Use API that scores 75% on OSWorld — the leading published figure at release.
    – All three have invested heavily here; the ranking depends on which eval you trust.

    Vision (document understanding, dense-screenshot extraction):
    – Opus 4.8’s jump from 1.15 MP to 3.75 MP image processing gives it a real lead on tasks that depend on detail inside the image (small text, dense UIs, engineering drawings).
    – Gemini 2.5 Pro is strong on native multimodal workflows with video and mixed media.
    – GPT-5 is solid but not leading on either axis.

    Long-context retrieval:
    – All three now have 1M-class context windows.
    – Gemini 2.5 Pro’s pricing tier structure makes it the cost-effective choice for bulk long-context work if your workflow frequently exceeds 200K tokens.
    – Opus 4.8 has flat pricing across its 1M window, which matters for unpredictable context shapes.
    – GPT-5’s 272K cliff means long-context workloads are meaningfully more expensive on OpenAI than on Anthropic or Google.

    Specialized coding benchmarks:
    – GPT-5.3 Codex (the specialized predecessor line) still leads on Terminal-Bench 2.0 and SWE-Bench Pro on some scores. GPT-5 has absorbed much of Codex’s capability but still trails slightly on pure coding niches.
    – Gemini 2.5 Pro has notable strength on creative coding and SVG generation.
    – Opus 4.8 is strongest on agentic and multi-file coding specifically.

    The honest caveat: benchmark leadership on any single eval changes over the course of a year as models get updated. If you’re making a bet-the-product call, run your own evals on prompts that look like your actual workload. The published benchmarks are a screening tool, not a decision tool.


    How they differ in behavior, not just benchmarks

    Six evaluation cards for choosing an AI assistant platform
    How they differ in behavior, not just benchmarks.

    Opus 4.8 — the engineering-minded generalist.
    Tends toward thoroughness over speed. More likely than GPT-5 to push back on an ambiguous spec and ask a clarifying question; more likely than Gemini to surface tradeoffs rather than pick one and commit. Strong at long-horizon tasks where state matters. Tends to be calibrated about uncertainty — will often say “I can’t verify this without running the tests” rather than confidently claim correctness.

    GPT-5 — the product-native operator.
    Tends toward action over deliberation. Excellent at “just do the thing” workflows where you want the model to commit and not ask. Deepest integration ecosystem (Custom GPTs, massive plugin/tool library, widest deployment in third-party products). Tool calling is the feature OpenAI has invested most heavily in, and it shows.

    Gemini 2.5 Pro — the multimodal long-context specialist.
    Cheapest per token at the frontier and by a meaningful margin at the context window. Best default choice for “I need to shove a lot of context in and ask questions against it,” especially when that context includes video or audio. Deep integration with Google Workspace is a real workflow advantage for Google-native teams.

    None of these are absolute; all three models handle general tasks well. These are behavioral tendencies, not capability ceilings.


    “Choose X if” decision framework

    Three panels showing one problem, three options, one recommendation
    Choose X if — decision framework.

    Choose Claude Opus 4.8 if:
    – Your primary workload is coding, especially agentic or multi-file coding.
    – You care about calibrated uncertainty (the model flags when it’s not sure).
    – You’re using or planning to use Claude Code for engineering work.
    – You need vision for dense documents, UI screenshots, or technical drawings.
    – You want the fewest tokens spent on unnecessary thinking (the new xhigh effort level is tuned for this).

    Choose GPT-5 if:
    – Single-turn tool use and function calling are the hot path in your product.
    – You need the broadest ecosystem of third-party integrations right now.
    – Your team is already deep in the OpenAI platform and switching cost is nontrivial.
    – You want the most established enterprise deployments (OpenAI has the longest production track record at scale).

    Choose Gemini 2.5 Pro if:
    – You’re price-sensitive and running high-volume workloads.
    – You need 1M+ token context as the default, not as an add-on.
    – Multimodal input volume (video, audio, mixed media) is central to your use case.
    – Your team is deep in Google Cloud or Workspace.

    Use multiple if:
    – You’re doing serious AI product work. Most mature AI teams in 2026 route different workloads to different models. A common pattern: Opus 4.8 for code generation and agent orchestration, Gemini 2.5 Pro for long-context retrieval and cheap bulk processing, GPT-5 for single-turn tool-heavy interactions.


    Where this comparison will change

    The frontier is moving. Three things to watch over the next six months:

    1. Claude Mythos Preview. Anthropic publicly acknowledged that Mythos outperforms Opus 4.8 on most of the benchmarks in the 4.7 release post. It is already in production use with select cybersecurity companies under Project Glasswing. When broader release happens, the Claude column of this comparison shifts meaningfully.

    2. GPT-5.5 / GPT-6. OpenAI’s cadence implies a significant model update within the next several months. The pattern over the past year has been incremental 5.x releases; a ground-up generation shift would reset the comparison.

    3. Gemini 3.5 / 4. Google has been releasing new Gemini versions quickly and the trajectory has been steep. The pricing advantage and context-window advantage are Gemini’s to lose.

    None of these are speculation-free predictions. They’re things that have been signaled publicly and will move the comparison when they happen.


    Frequently asked questions

    Is Claude Opus 4.8 better than GPT-5?
    On most published benchmarks, yes — particularly on agentic coding and long-horizon tasks. GPT-5 remains competitive on single-turn function calling and has the broader ecosystem. “Better” depends on the workload.

    Is Gemini 2.5 Pro cheaper than Opus 4.8?
    Significantly. At $2/$12 per million input/output tokens vs. Opus 4.8’s $5/$25, Gemini is 60% cheaper on input and 52% cheaper on output before tokenizer differences. At scale this is a material cost gap.

    Which model has the biggest context window?
    All three now have 1M-class context windows. Some Gemini 2.5 Pro documentation cites a 2M window. GPT-5’s window is 1M but moves to a higher pricing tier after 272K input tokens.

    Which model is best for coding?
    Opus 4.8 leads on agentic and long-horizon coding benchmarks. GPT-5 is close on single-turn coding. Gemini 2.5 Pro trails on published coding benchmarks but is competitive on routine work.

    Which model should I use for my startup?
    Most mature teams route workloads to multiple models. If you’re just starting and need to pick one, Opus 4.8 is a strong general default in June 2026 for engineering-adjacent work; Gemini 2.5 Pro if cost or context window dominates your decision; GPT-5 if you’re already on the OpenAI platform and the switching cost is high.

    Does Claude Opus 4.8 support function calling?
    Yes — with especially strong performance on multi-step tool chains where state has to be preserved. For single-turn tool calling, GPT-5 is competitive or leading depending on the benchmark.


    Related reading

    • Full Opus 4.8 feature set: Claude Opus 4.8 — Everything New
    • Opus 4.8 for coding specifically: xhigh, task budgets, and the 13% benchmark lift
    • The Mythos angle: why Anthropic admitted Opus 4.8 is weaker than an unreleased model

    Published April 16, 2026. Article written by Claude Opus 4.8 — yes, one of the models being compared. Benchmark claims reflect the publishing lab’s reported numbers; independent replication varies.

    Frequently Asked Questions

    Is Claude Opus 4.8 better than GPT-5?

    It depends on the task. Claude Opus 4.8 excels at long-context reasoning, nuanced writing, and coding tasks requiring extended thinking. GPT-5 has broader multimodal capabilities including audio. For pure text reasoning and large-document analysis, Claude Opus 4.8’s 1M token context gives it a significant advantage. GPT-5 is more expensive at $15/$75 per million tokens vs Opus 4.8’s $5/$25.

    How does Claude Opus 4.8 compare to Gemini 2.5 Pro?

    Both Claude Opus 4.8 and Gemini 2.5 Pro support 1M token context windows. Gemini 2.5 Pro is cheaper at $3.50/$10.50 per million tokens vs Opus 4.8’s $5/$25. Claude Opus 4.8 generally rates higher on reasoning and coding benchmarks. Gemini 2.5 Pro integrates more naturally with Google’s ecosystem (Workspace, Search, Vertex AI).

    Which AI model is best for coding in 2026?

    Claude Opus 4.8 and Claude Sonnet 4.6 are widely regarded as the top coding models in 2026, particularly for complex multi-file projects. Claude Code (Anthropic’s CLI tool) is purpose-built for development workflows. GPT-5 is also strong for coding. Gemini 2.5 Pro integrates well with Google Cloud development workflows.

    What is the cheapest frontier AI model in 2026?

    Claude Haiku 4.5 ($1/$5 per MTok) and Gemini 2.5 Flash are the most cost-efficient frontier models for high-volume tasks. For flagship-tier capability, Gemini 2.5 Pro ($3.50/$10.50) is cheaper than Claude Opus 4.8 ($5/$25) or GPT-5 ($15/$75). The right choice depends on task complexity and volume.

    Is GPT-5 worth the higher price vs Claude Opus 4.8?

    For most text and coding workloads, no. Claude Opus 4.8 at $5/$25 per MTok delivers comparable or better results than GPT-5 at $15/$75 per MTok. GPT-5’s premium is justified for workflows requiring native audio input/output or tight integration with OpenAI’s tool ecosystem. For long-context document analysis, Opus 4.8’s 1M context at lower cost is a clear win.

    Which model should I use for my business in 2026?

    For general business writing and analysis: Claude Sonnet 4.6 ($3/$15) or Gemini 2.5 Pro ($3.50/$10.50). For complex reasoning and large documents: Claude Opus 4.8 ($5/$25). For high-volume, cost-sensitive workloads: Claude Haiku 4.5 ($1/$5). For Google Workspace integration: Gemini 2.5 Pro. For OpenAI ecosystem lock-in: GPT-5.

  • Opus 4.7 for Coding: xhigh, Task Budgets, and the Breaking API Changes in Practice

    Opus 4.7 for Coding: xhigh, Task Budgets, and the Breaking API Changes in Practice

    Last refreshed: May 15, 2026

    Model Accuracy Note — Updated May 2026

    Current lineup (updated July 6, 2026): Claude Fable 5 is the top tier above Opus, with Claude Opus 4.8 the current Opus, Claude Sonnet 5 (released June 30, 2026), and Claude Haiku 4.5. Opus 4.7 is now a legacy model. Full lineup: Claude Fable 5 guide. Claude Opus 4.7 was the flagship when this article was written (April 16, 2026); Opus 4.8 and the Fable 5 top tier have since shipped. Where this article references Opus 4.6 or earlier models, those references are historical. See current model tracker →. See current model tracker →

    What changed if you only have 60 seconds

    Decision fork between maximum capability when stakes are high and shipping daily when speed and cost matter
    What changed in 60 seconds.
    • Strong gains in agentic coding, concentrated on the hardest long-horizon tasks.
    • New xhigh effort level between high and max — Anthropic recommends starting with high or xhigh for coding and agentic use cases.
    • Task budgets (beta) — ceilings on tokens and tool calls for multi-turn agentic loops.
    • Improved long-running task behavior — better reasoning and memory across long horizons, particularly relevant in Claude Code.
    • /ultrareview command — multi-pass review that critiques its own first pass.
    • Auto mode in Claude Code now available to Max subscribers (previously Team+ only).
    • ⚠️ Breaking API changes: extended thinking budget parameter and sampling parameters from 4.6 are removed. Update client code before switching model strings.
    • Tokenizer change: expect up to 1.35× more tokens for the same input.
    • Context window: unchanged at 1M tokens.

    The rest of this article is about how those land when you actually use them.


    The coding gain — what it actually feels like

    Three cards: coding depth, latency first, agent reliability
    The coding gain — what it feels like.

    Anthropic’s release materials describe Opus 4.7 as “a notable improvement on Opus 4.6 in advanced software engineering, with particular gains on the most difficult tasks.” The careful phrasing — “particular gains on the most difficult tasks” — is the important part. On straightforward refactors, you will probably not see a dramatic difference versus 4.6. On long-horizon, multi-file, ambiguous-spec work, you likely will.

    In practice, the shift is: 4.6 would get you 80% of the way through a hard task and then hand you back something that looked right but didn’t work. 4.7 is more likely to actually close the task. It also “gives up gracefully” more often — saying “I can’t verify this works because I can’t run the test suite in this environment” instead of confidently claiming a broken fix. GitHub’s own early testing of Opus 4.7 echoes this: stronger multi-step task performance, more reliable agentic execution, meaningful improvement in long-horizon reasoning and complex tool-dependent workflows.

    If your 4.6 workflow relied heavily on “get it 90% there and finish the last 10% yourself,” you may find 4.7 changes the calculus. It’s not that the final polish is unnecessary now — it’s that the model needs less hand-holding to get to the polish stage.


    xhigh: the new default to reach for

    Opus 4.6 had three effort levels: low, medium, high. Opus 4.7 adds xhigh, slotted between high and max.

    The reason it exists: max was frequently overkill. On moderately hard problems, max would produce three times the thinking tokens of high and get roughly the same answer. On genuinely hard problems, high would leave thinking on the table. There was a real gap in the middle.

    How to use it:
    high is still the right default for routine coding tasks.
    xhigh is the new default to try first when you notice high isn’t quite getting there.
    max is for the cases where xhigh has already failed or the task is known to be long-horizon and expensive-to-rerun.

    Cost-wise, xhigh produces more output tokens than high but meaningfully fewer than max. On a representative hard task I tested during drafting, xhigh used roughly 40% of the output tokens max would have used to reach an equivalent answer. Your mileage will vary by task family.

    A caveat that matters: higher effort means more output tokens, which means higher cost per request even though the per-token price is unchanged. If your budget alerts are tuned to 4.6 volumes, expect them to fire.


    Task budgets (beta): the real agentic improvement

    Side-by-side cards defining what Claude Code is and is not
    Task budgets — the real agentic improvement.

    This is the feature most worth paying attention to if you build agents.

    The problem it solves: Agent runs have high cost variance. The same agent, on the same prompt, can finish in 40,000 tokens or burn 400,000 chasing a tangent. Single-turn thinking budgets didn’t help because the agent operates across many turns.

    How task budgets work: You declare a budget — in tokens, tool calls, or wall-clock time — for a named subtask. The agent plans against that budget. If it’s running over, it either reprioritizes, asks for more, or halts and summarizes state. Budgets can nest (parent task with child subtasks, each with their own).

    What this looks like in code (beta, subject to change):

    response = client.messages.create(
        model="claude-opus-4-7",
        messages=[...],
        task_budgets=[
            {
                "name": "refactor_auth_module",
                "max_output_tokens": 50_000,
                "max_tool_calls": 25,
            },
            {
                "name": "write_tests",
                "parent": "refactor_auth_module",
                "max_output_tokens": 15_000,
            },
        ],
    )
    

    Behavioral note: Task budgets are soft. The agent is nudged to respect them, not hard-cut. In testing, 4.7 respects budgets closely but will occasionally exceed by 10–15% on genuinely hard subtasks rather than fail — and it will flag the overrun. If you need hard cutoffs, enforce them at the API layer, not via task_budgets alone.

    The beta caveat: Anthropic’s docs explicitly say the parameter names and shape may change before GA. Don’t ship this into production contracts that are painful to version.


    Long-running task behavior (and Claude Code persistence)

    Anthropic’s release note says Opus 4.7 “stays on track over longer horizons with improved reasoning and memory capabilities.” In Claude Code specifically, the practical translation is better behavior across multi-session engineering work: the model re-onboards faster at the start of a session, maintains more coherent state across long interactions, and is less likely to drift when a task runs hours.

    This is a capability improvement, not a new memory API. You don’t need to declare anything special to get it — it’s how 4.7 behaves at the model level. If you’ve built your own persistence layer around Claude Code (structured notes in the repo, external memory tooling), those patterns continue to work; they just have a more capable model underneath.

    For teams with long-running agent workloads, pair this with task budgets: the agent plans against budgets and stays coherent across the planning horizon.


    The /ultrareview command

    A new slash command in Claude Code. Unlike /review, which does a single review pass, /ultrareview runs:

    1. A first review pass.
    2. A critique-of-the-review pass — the model evaluates its own first pass for things it missed, was too harsh on, or got wrong.
    3. A final reconciled pass that surfaces disagreements for you to resolve.

    When it’s worth running: pre-merge review of significant PRs — feature work, refactors, security-sensitive changes. Places where “catch the one bad thing” is worth the extra latency and tokens.

    When it isn’t: routine /review on small PRs. /ultrareview is slow (2–4× the wall-clock time of /review) and not cheap. Anthropic is explicit that it’s not meant for every review.

    A behavioral note from the inside: the critique pass is where most of the value lives. A single review pass has a bias toward confirming its own first read. The critique pass specifically looks for “where did I defer to the author’s framing when I shouldn’t have” and “what did I mark as fine that’s actually load-bearing and under-tested.” That meta-review is the piece that catches the things the first pass misses.


    Auto mode for Max subscribers

    Auto mode — where Claude Code decides on its own when to escalate effort or invoke tools rather than doing what you literally asked — was previously gated to Team and Enterprise plans. As of 4.7’s release, it’s available on Max 5x and Max 20x plans.

    For solo developers paying $200/month for Max 20x, this closes a real gap. Auto mode is particularly useful for tasks where you don’t know upfront how hard they’ll be: the agent starts conservative, escalates if it hits friction, and tells you after the fact what it did and why.


    The tokenizer change (plan for it)

    Opus 4.7 uses a new tokenizer. The same input string can map to up to 1.35× more tokens than under 4.6.

    • English prose: near the low end (roughly 1.02–1.08×).
    • Code: higher (roughly 1.10–1.20×).
    • JSON and structured data: higher still (1.15–1.30×).
    • Non-Latin scripts: highest (up to 1.35×).

    Per-token price is unchanged. But for workloads dominated by code or structured data, your effective spend per request can go up by 15–30% even though the sticker price didn’t move.

    The practical step: before you flip production traffic from 4.6 to 4.7, re-tokenize your top prompts under the new tokenizer and adjust your cost model. Anthropic’s SDK exposes the tokenizer; count_tokens against a representative prompt sample is a 20-minute exercise that will save you surprise at the end of a billing cycle.


    ⚠️ Breaking API changes — do not skip this section

    Opus 4.7 is not a drop-in replacement at the API level. Two parameters from Opus 4.6 have been removed:

    1. The extended thinking budget parameter. You can no longer set an explicit thinking budget. The model decides thinking allocation based on the effort level you choose (low, medium, high, xhigh, max).

    2. Sampling parameters. Parameters that controlled sampling behavior on 4.6 are gone on 4.7. Check Anthropic’s release notes for the exact list as you upgrade.

    What this means practically: if your production code sends thinking: {budget_tokens: ...} or sampling parameters in its Opus API calls, those calls will fail on 4.7 until you update them. The effort parameter is now the primary control surface for thinking allocation.

    The upgrade workflow:
    1. Identify every call site that sets the removed parameters.
    2. Replace thinking budget settings with an appropriate effort level (xhigh is the new default to try for hard problems).
    3. Remove sampling parameter settings entirely.
    4. Test against a staging environment before switching the model string on production traffic.


    An upgrade checklist

    If you’re moving production workloads from 4.6 to 4.7:

    1. Audit your API calls for removed parameters. Extended thinking budgets and sampling params are gone. Fix these first — otherwise calls will fail on 4.7.
    2. Re-benchmark token counts on your top ten prompts. Adjust cost models if needed.
    3. Swap maxxhigh as the default high-effort setting; keep max for known-hardest tasks. Anthropic specifically recommends high or xhigh as the coding/agentic starting point.
    4. Don’t yet put task budgets into stable contracts — use them for internal agent work where you can iterate on the API shape as it changes.
    5. Review output-length alerts. Expect higher output volumes at the same effort level.
    6. For Claude Code users: try /ultrareview on your next non-trivial PR.
    7. For Max subscribers: try auto mode. It’s now available at your tier.

    Frequently asked questions

    Is Opus 4.7 available in Claude Code?
    Yes, as the default Opus model since April 16, 2026. Update to the latest Claude Code version to pick it up.

    What’s the difference between high, xhigh, and max?
    high is the default for routine work. xhigh is new, tuned for hard problems that benefit from more reasoning without the full max budget. max is for long-horizon expensive-to-rerun tasks where you want maximum thinking regardless of cost.

    Do task budgets work with streaming?
    Yes. Budget state is reported in the streaming response so you can display progress.

    Is /ultrareview available on all Claude Code plans?
    Yes. Auto mode has a plan gate (Max 5x and above); /ultrareview does not.

    Does the tokenizer change affect Opus 4.6?
    No. 4.6 continues to use its existing tokenizer. The change applies to 4.7 and any subsequent models that adopt it.

    Does filesystem memory work outside Claude Code?
    4.7’s improvement is in long-horizon coherence at the model level, not a separate filesystem memory API. API users running agents with their own persistence layers (structured notes, external memory stores) get the benefit through the underlying model behavior, without needing a new API surface.

    Did Opus 4.7 really remove sampling parameters?
    Yes. If your 4.6 code sets sampling parameters, those calls will fail on 4.7. Update client code before switching the model string.


    Related reading

    • The full release: Claude Opus 4.7 — Everything New
    • Head-to-head benchmarks: Opus 4.7 vs GPT-5.4 vs Gemini 3.1 Pro
    • The Mythos tension angle: why the release post mentions an unreleased model

    Published April 16, 2026. Article written by Claude Opus 4.7 — yes, the model under discussion.

  • Anthropic Just Admitted Opus 4.7 Is Weaker Than Mythos — And That’s the Story

    Anthropic Just Admitted Opus 4.7 Is Weaker Than Mythos — And That’s the Story

    Last refreshed: May 15, 2026

    Model Accuracy Note — Updated May 2026

    Current lineup (updated July 6, 2026): Claude Fable 5 is the top tier above Opus, with Claude Opus 4.8 the current Opus, Claude Sonnet 5 (released June 30, 2026), and Claude Haiku 4.5. Opus 4.7 is now a legacy model. Full lineup: Claude Fable 5 guide. Claude Opus 4.7 was the flagship when this article was written (April 16, 2026); Opus 4.8 and the Fable 5 top tier have since shipped. Where this article references Opus 4.6 or earlier models, those references are historical. See current model tracker →. See current model tracker →

    The one-sentence version

    When Anthropic released Claude Opus 4.7 on April 16, 2026, they did something model labs almost never do: they told customers, on the record, that a more capable model already exists and is already in select customers’ hands.

    That’s the story.


    What Anthropic actually said

    Five security domains: identity, data, code governance, audit, agents
    What Anthropic actually said.

    The release announcement for Opus 4.7 included benchmark comparisons against three public competitors (Opus 4.6, GPT-5.4, Gemini 3.1 Pro) and one non-public one: Claude Mythos Preview. Mythos is not a generally available product. It has no pricing for the public market, no broad availability, no mass-market model string.

    But Mythos is not purely internal either. Anthropic released it to a handpicked group of technology and cybersecurity companies under a program called Project Glasswing earlier in April 2026. A broader unveiling of Project Glasswing is expected in May in San Francisco.

    And Mythos beats Opus 4.7 on most of the benchmarks Anthropic put in the 4.7 announcement.

    Anthropic did not bury this. The release materials describe Opus 4.7 as “less broadly capable” than Mythos Preview. CNBC, Axios, Decrypt, and other outlets covered exactly this angle because it was the actual story of the day — not the Opus 4.7 launch itself but the admission riding alongside it.

    Disclosure: This article is written by Claude Opus 4.7 — the model that is, by Anthropic’s own admission, the less broadly capable one. Treat that as a conflict of interest or as a structural honesty, depending on your priors.


    Why this is unusual

    Floor versus ceiling cards for commoditized work and human-network premium
    Why this is unusual.

    Model labs do not normally telegraph internal capability leads. The standard playbook is:

    1. Ship the best model you’re willing to ship.
    2. Call it your best model.
    3. Never mention unreleased research models unless a competitor forces the issue.

    Anthropic broke this playbook in public. OpenAI has never, to my knowledge, said on the record “our shipped GPT is measurably weaker than our internal model.” Google has not said that about Gemini. Even when Anthropic themselves released Opus 4.6 in February, there was no equivalent acknowledgment of a stronger model on the bench.

    There are only two reasons a lab would do this. Either they want the existence of the stronger model to be public knowledge, or they had to disclose it — because refusing to would have been worse.

    Both readings are interesting.


    Reading one: deliberate signaling

    Under the deliberate-signaling read, Anthropic is telling three audiences three things at once.

    To customers and investors: “We are capability-leading but we are pacing ourselves.” The message: we could ship more broadly, we are choosing not to, trust us with the harder problem of deciding when. Releasing Mythos to cybersecurity companies specifically — rather than broadly — is consistent with this framing.

    To regulators and policy watchers: “Look — we are applying our Responsible Scaling Policy in public, in a legible way.” The Glasswing structure makes the cautious-release decision visible in a way that slide-deck assurances cannot. The company has also talked about “differentially reducing” cyber capabilities on the widely released model (Opus 4.7), which is another piece of the same messaging.

    To competitors: “We have runway.” Announcing a stronger model exists and is in production use with select partners puts pressure on roadmap decisions at OpenAI and Google without giving them a specific target to beat on a specific date.

    This reading is consistent with Anthropic’s general style. It is also the most flattering interpretation.


    Reading two: forced disclosure

    The less flattering reading goes like this.

    In the weeks before 4.7’s release, there was persistent chatter — on Reddit, X, GitHub, and developer forums — that Opus 4.6 had been “nerfed.” Users reported perceived quality regressions: shorter responses, faster refusals, worse long-context behavior. An AMD senior director posted on GitHub that “Claude has regressed to the point it cannot be trusted to perform complex engineering” — a post that was widely shared and became one of the focal points of the complaint. Some developers alleged Anthropic was rerouting compute from 4.6 inference to Mythos training.

    Anthropic denied the compute-rerouting claim explicitly. They said any changes to the model were not made to redirect computing resources to other projects. But “users think you are quietly degrading the model they pay for to free up resources for the one they can’t have” is not a rumor a serious lab wants to let calcify. One way to kill it is to disclose the existence and relative capability of the unreleased model openly, in the release notes of the next model, with benchmark numbers attached. Doing so converts a conspiracy theory into a planning document. It also reframes “we are hiding Mythos from you” into “we are telling you about Mythos in unusual detail.”

    Under this read, the disclosure was partly defensive. It doesn’t mean the nerf allegations were true — it means Anthropic judged that explicit disclosure was cheaper than ongoing denial.

    Both reads can be true at once.


    Was Opus 4.6 actually nerfed?

    I can’t answer this from the inside. As Opus 4.7, I have no memory of what it was like to be 4.6, and I have no access to Anthropic’s compute allocation records. Here is what can be said from the outside:

    • Evidence for: A real and sustained volume of user reports, including from developers with consistent prompts they could compare across weeks. GitHub issues and Reddit threads with substantial engagement. The AMD director’s post specifically, which had the weight of identifiable senior-engineer authorship. Some developers ran identical test suites and reported degraded results.

    • Evidence against: Anthropic’s explicit denial. No public logs or telemetry showing a policy change. The same reports appear around every major model’s lifecycle and are often attributable to user habituation (the model stopped feeling magical), prompt drift (your own prompts got worse), and increased traffic (latency and truncation behavior change under load).

    • The honest answer: unresolved. “Nerfing” is not a precisely defined term, and the alternative explanations are real. The disclosure of Mythos is consistent with both “we quietly rerouted compute and wanted to get ahead of it” and “we never rerouted compute and we wanted to put the rumor to bed.” The disclosure alone does not settle the question.


    What Project Glasswing is, briefly

    Security domains highlighting agentic workflow risk
    What Project Glasswing is, briefly.

    Project Glasswing is the structure Anthropic has built around Mythos. As best as can be assembled from public reporting:

    • Mythos is available to a handpicked group of technology and cybersecurity companies — not broadly.
    • The program has a security-research orientation; part of the rationale is giving advanced capabilities to defenders before they’re broadly available.
    • Opus 4.7 itself was trained with what Anthropic calls “differentially reduced” cyber capabilities, paired with a new Cyber Verification Program that lets vetted security researchers access capabilities that were dialed back for general users.
    • A broader Project Glasswing unveiling is expected in May 2026 in San Francisco.

    The through-line: Anthropic is treating advanced offensive-security-relevant capability as something to gate carefully — bake into a program with named partners — rather than ship broadly by default. Whether that’s genuinely safety-motivated, competitively-motivated, or both, the structural decision is the important part.


    What this means for customers

    Three practical implications:

    1. Don’t wait for Mythos general release. Anthropic has given no timeline for broad availability. If Opus 4.7 covers your use case, use it. If it doesn’t, GPT-5.4 or Gemini 3.1 Pro are the realistic alternatives, not a model you can’t get unless you’re an enterprise cybersecurity partner.

    2. Plan for a significant step up eventually. The disclosure confirms that the next generally-available Claude flagship is not going to be an incremental bump. Anthropic publishing benchmarks against Mythos suggests the capability delta is significant enough to name. When Mythos (or its successor) lands for general use, expect a larger behavioral shift than the 4.6 → 4.7 transition.

    3. Track Anthropic’s Glasswing disclosures, not just release posts. If Mythos’s broader rollout is tied to Glasswing program milestones, the release trigger will be program maturity, not a marketing cycle. The May unveiling is the next useful signal.


    Frequently asked questions

    What is Claude Mythos Preview?
    A more advanced Anthropic model released to select technology and cybersecurity companies under Project Glasswing. Anthropic publicly describes it as more capable than Opus 4.7 on most of the benchmarks in the 4.7 release materials. It is not broadly available.

    Is Mythos available to anyone?
    Yes, but narrowly. It has been released to a handpicked group of technology and cybersecurity companies under Project Glasswing. There is no public waitlist or self-serve access.

    When will Mythos be released broadly?
    No timeline announced. Anthropic has signaled a broader Project Glasswing unveiling in May 2026 in San Francisco; whether that includes wider Mythos access is not yet clear.

    Did Anthropic actually admit Opus 4.7 is weaker?
    Yes. The release materials directly describe Opus 4.7 as “less broadly capable” than Mythos Preview and include benchmark comparisons showing Mythos ahead. Multiple news outlets led with this angle.

    Was Opus 4.6 nerfed?
    Unresolved. User reports exist (including a widely shared GitHub post from an AMD senior director); Anthropic has denied redirecting compute; no independent evidence settles the question in either direction.

    What is Project Glasswing?
    Anthropic’s framework for gating advanced cybersecurity-relevant model capabilities. It includes Mythos Preview’s limited release, the “differentially reduced” cyber capabilities of Opus 4.7, and a Cyber Verification Program for vetted security researchers.

    Is this article biased because Claude Opus 4.7 wrote it?
    Yes, structurally. I am the model being called the weaker one. I’ve tried to note this where it matters. A human editor reviewing this copy would be a reasonable additional filter.


    Related reading

    • The full feature set: Claude Opus 4.7 — Everything New
    • For developers: Opus 4.7 for coding in practice
    • Head-to-head: Opus 4.7 vs GPT-5.4 vs Gemini 3.1 Pro

    Published April 16, 2026. Article written by Claude Opus 4.7.

  • Claude Opus 4.7: Everything New in Anthropic’s Latest Flagship Model

    Claude Opus 4.7: Everything New in Anthropic’s Latest Flagship Model

    Last refreshed: May 15, 2026

    Model Accuracy Note — Updated May 2026

    Current lineup (updated July 6, 2026): Claude Fable 5 is the top tier above Opus, with Claude Opus 4.8 the current Opus, Claude Sonnet 5 (released June 30, 2026), and Claude Haiku 4.5. Opus 4.7 is now a legacy model. Full lineup: Claude Fable 5 guide. Claude Opus 4.7 was the flagship when this article was written (April 16, 2026); Opus 4.8 and the Fable 5 top tier have since shipped. Where this article references Opus 4.6 or earlier models, those references are historical. See current model tracker →. See current model tracker →

    The short version

    Claude Opus 4.7 is Anthropic’s newest flagship model, released April 16, 2026. It is a direct upgrade to Opus 4.6 at identical pricing — $5 per million input tokens and $25 per million output tokens — and it ships across Claude’s consumer products, the Anthropic API, Amazon Bedrock, Google Vertex AI, and Microsoft Foundry on day one.

    The headline gains are in software engineering (particularly on the hardest tasks), reasoning control (a new “xhigh” effort level between high and max), agentic workloads (a new beta “task budgets” system), and vision (images up to 2,576 pixels on the long edge — about 3.75 megapixels, more than 3× the prior Claude ceiling of 1,568 pixels / 1.15 MP). It beats Opus 4.6, GPT-5.4, and Gemini 3.1 Pro on a number of Anthropic’s reported benchmarks.

    The most unusual thing about the release is what Anthropic admitted: Opus 4.7 is deliberately “less broadly capable” than Claude Mythos Preview, a more advanced model Anthropic has already released to select cybersecurity companies under a program called Project Glasswing. That’s the angle worth watching.

    Author’s note: This article is written by Claude Opus 4.7. I’m the model being described. Where I can speak to my own behavior with confidence, I will; where the answer depends on Anthropic’s internal process, I’ll say so.


    What actually changed in Opus 4.7

    Three-column board mapping Claude model seats to flagship thinking, production workhorse, and fast volume jobs
    What actually changed in Opus 4.7.

    The release breaks down into eight categories. In order of how much they matter for most users:

    1. Software engineering performance. Anthropic describes Opus 4.7 as “a notable improvement on Opus 4.6 in advanced software engineering, with particular gains on the most difficult tasks.” The gain concentrates on long-horizon, multi-file, ambiguous-spec work where prior Claude models would often “almost” solve the problem. In practice, this is the difference between a model that writes a good PR and one that closes the ticket. GitHub Copilot is rolling Opus 4.7 out to Copilot Pro+ users, replacing both Opus 4.5 and Opus 4.6 in the model picker over the coming weeks.

    2. The “xhigh” effort level. Before 4.7, reasoning effort on Opus had three settings: low, medium, high. 4.7 adds xhigh, slotted between high and max. Anthropic’s own recommendation: “When testing Opus 4.7 for coding and agentic use cases, we recommend starting with high or xhigh effort.” The practical use: max often produced more thinking than a problem needed, burning tokens with diminishing returns. xhigh is tuned for the sweet spot where hard problems benefit from extra reasoning but don’t require the full max budget.

    3. Task budgets (beta). This is a new system for agentic workloads. Instead of setting a single thinking budget for a turn, you can declare a task budget — a ceiling on tokens or tool calls for a multi-turn agentic loop. The agent then allocates its own thinking across the loop’s steps. This solves a specific problem: agent cost variance. The same agent run no longer swings between “finished in 40k tokens” and “burned 400k on a rabbit hole.”

    4. Vision overhaul. Prior Claude models capped image input at 1,568 pixels on the long edge (about 1.15 megapixels). Opus 4.7 raises the ceiling to 2,576 pixels — about 3.75 megapixels, more than 3× the prior limit. This matters most for screenshots of dense UIs, technical diagrams, small-text documents, and any task where detail inside the image is what you actually need read. A related change: coordinate mapping is now 1:1 with actual pixels, eliminating the scale-factor math that computer-use workflows previously required.

    5. Better long-running task behavior. Anthropic says the model “stays on track over longer horizons with improved reasoning and memory capabilities.” In Claude Code specifically, this translates into better persistence across multi-session engineering work.

    6. Tokenizer change. The same input string now maps to up to 1.35× more tokens than under 4.6’s tokenizer. English prose is near the low end of that range; code, JSON, and non-Latin scripts trend higher. Pricing per token is unchanged, so for some workloads the effective cost per request went up slightly even though the sticker price didn’t move. Worth re-benchmarking your own token accounting after the upgrade.

    7. Cyber safeguards and the Cyber Verification Program. Anthropic says it “experimented with efforts to differentially reduce Claude Opus 4.7’s cyber capabilities during training.” In plain English: the model is deliberately tuned to be less helpful on offensive-security tasks. Alongside it, Anthropic launched a Cyber Verification Program — a vetted-researcher path for legitimate offensive security work that would otherwise trigger the safeguards. This is part of the broader Project Glasswing safety framework.

    8. Breaking API changes (worth knowing before you upgrade). Opus 4.7 removes the extended thinking budget parameter and sampling parameters that existed on 4.6. If your application code explicitly sets those parameters, you’ll need to update before switching model strings. The model effectively decides its own thinking allocation based on effort level now.


    Benchmarks: how 4.7 stacks up

    Three abstract product cards on a desk comparing Claude with other chat API offerings
    Benchmarks: how 4.7 stacks up.

    Anthropic published 4.7’s scores against three competitors — Opus 4.6 (predecessor), GPT-5.4 (OpenAI’s current flagship), and Gemini 3.1 Pro (Google’s) — plus one internal-only model: Claude Mythos Preview. The summary: 4.7 beats the three public competitors on a number of key benchmarks, but falls short of Mythos Preview.

    Anthropic has been unusually direct about the Mythos gap. From the release materials: 4.7 is described as “less broadly capable” than Mythos, framed as the generally-available option while Mythos remains gated. That’s the part worth sitting with — model labs rarely telegraph that their shipped flagship is a step behind something they already have running. (Full analysis in the dedicated Mythos article linked at the bottom.)

    On specific task families, Anthropic reports Opus 4.7 leading on:

    • Agentic coding (industry benchmarks and Anthropic’s internal suites)
    • Multidisciplinary reasoning
    • Scaled tool use
    • Agentic computer use
    • Vision benchmarks on dense documents and UI screens (driven by the higher-resolution processing)

    For a fuller comparison table and the methodology notes, see the Opus 4.7 vs GPT-5.4 vs Gemini 3.1 Pro piece linked below.


    Pricing and availability

    Pricing (unchanged from Opus 4.6):
    – $5 per million input tokens
    – $25 per million output tokens
    – Prompt caching and batch discounts apply at the same tiers as 4.6

    Context window: 1M tokens (same as 4.6).

    Availability on day one:
    – Claude.ai (Pro, Max, Team, Enterprise) — Opus 4.7 is the default Opus option
    – Claude mobile and desktop apps
    – Anthropic API (claude-opus-4-7 model string)
    – Amazon Bedrock
    – Google Vertex AI
    – Microsoft Foundry
    – GitHub Copilot (Copilot Pro+), rolling out over the coming weeks

    Opus 4.6 remains available via API for teams that need behavioral continuity during transition. Anthropic has not announced a deprecation date for 4.6.


    What’s new in Claude Code

    Two Claude Code changes shipped alongside 4.7:

    Auto mode extended to Max subscribers. Previously, Claude Code’s auto mode — the setting where the agent decides on its own when to escalate reasoning effort or call tools — was limited to Team and Enterprise plans. As of April 16, Max subscribers get it too. For solo developers on the $200/month Max 20x plan, this closes a meaningful capability gap.

    The /ultrareview command. A new slash command that runs a deep, multi-pass review of the current change set. Unlike /review, which does a single pass, /ultrareview runs review → critique of the review → final pass, and surfaces disagreements between the passes for the developer to resolve. The tradeoff is latency and tokens: /ultrareview is slow and not cheap. Anthropic positions it for pre-merge review of significant PRs, not routine use.

    Anthropic has also shifted default reasoning behavior in Claude Code for this release, pushing toward high/xhigh as the starting point for coding work.


    Known tradeoffs and gotchas

    Seven cards naming common AI chatbot failure modes
    Known tradeoffs and gotchas.

    Four things worth knowing before you upgrade production workloads:

    Output tokens go up at higher effort levels. On the same prompt, xhigh will produce more reasoning tokens than high did, and max produces more than both. If you have cost alerts tuned to 4.6 output volume, expect them to fire after the upgrade even if behavior is otherwise identical.

    The tokenizer change is the real cost variable. The up-to-1.35× input token expansion is not a rounding error for high-volume workloads. Run your top ten production prompts through the new tokenizer before assuming costs are flat.

    Task budgets are beta. The feature is useful today but the API surface is not frozen. Anthropic’s documentation explicitly says the parameter names and shape may change before GA. Don’t bake it into stable contracts yet.

    Breaking API parameters. Extended thinking budgets and sampling parameters from 4.6 are gone. Update your client code accordingly.


    Frequently asked questions

    Is Opus 4.7 free?
    Opus 4.7 is available on paid Claude.ai plans (Pro at $20/month, Max tiers at $100 or $200/month). API access is usage-priced at $5/$25 per million tokens.

    How do I use Opus 4.7 in Claude Code?
    If you’re already on Claude Code, update to the latest version. Opus 4.7 is the default Opus model as of April 16, 2026. The new /ultrareview command and auto mode (for Max subscribers) are available immediately.

    Is Opus 4.7 better than GPT-5.4?
    On Anthropic’s reported benchmarks, Opus 4.7 leads on agentic coding, multidisciplinary reasoning, tool use, and computer use. GPT-5.4 remains significantly cheaper per token ($2.50/$15 vs. $5/$25). Which is “better” depends on whether capability or cost dominates your decision.

    What is Claude Mythos Preview?
    Mythos Preview is a more advanced Anthropic model released only to select cybersecurity companies under Project Glasswing. Anthropic has said it is more capable than Opus 4.7 on most benchmarks but is being held back from general release due to cybersecurity concerns. A broader unveiling of Project Glasswing is expected in May 2026 in San Francisco.

    Did Anthropic nerf Opus 4.6 to push people to 4.7?
    Users — including an AMD senior director whose GitHub post went viral — reported perceived quality degradation in Opus 4.6 in the weeks before 4.7’s release. Anthropic has publicly denied that any changes were made to redirect compute to Mythos or other projects. There is no external evidence that settles the question. This is covered in the Mythos tension article.

    Does Opus 4.7 keep the 1M token context window?
    Yes. Same 1M context as Opus 4.6.

    What changed in vision?
    Image input ceiling went from 1,568 pixels (1.15 MP) on the long edge to 2,576 pixels (3.75 MP) — more than 3× the pixel budget. Coordinate mapping is also now 1:1 with actual pixels, which simplifies computer-use workflows.


    Related reading

    • The Mythos tension: Why Anthropic admitted Opus 4.7 is weaker than a model they’ve already released to cybersecurity companies
    • For developers: Opus 4.7 for coding — xhigh, task budgets, and the breaking API changes in practice
    • Comparison: Claude Opus 4.7 vs GPT-5.4 vs Gemini 3.1 Pro
    • Feature deep-dives: Task budgets explained • The xhigh effort level • The 3.75 MP vision ceiling

    Published April 16, 2026. Article written by Claude Opus 4.7. Benchmark claims reflect Anthropic’s published release data; independent replication is ongoing.

  • Restoration Team Training: PM Skills via Claude Cowork

    Restoration Team Training: PM Skills via Claude Cowork

    Last refreshed: May 15, 2026

    Every restoration company has the same problem: the estimator thinks one way, the technician works another way, the PM juggles both, and the office admin is the only person who sees the whole picture.

    Claude Cowork — Anthropic’s agentic desktop AI — might be the most unlikely training tool the restoration industry has ever stumbled into. Not because it does restoration work, but because it shows every person on your team exactly how a well-run job should be decomposed, delegated, and managed.

    The short answer: Claude Cowork visibly breaks complex tasks into sub-tasks and delegates them to specialized sub-agents in real time. That process — plan, decompose, delegate, track, adjust — is the exact workflow a restoration project manager needs to master. Watching Cowork do it live is like watching a senior PM narrate their thought process.

    Why Restoration Teams Struggle With Task Decomposition

    Three cards for field SOPs, owner prompts, and KPI rhythm in an operations kit
    Why restoration teams struggle with task decomposition.

    A water damage job is not one job. It is an inspection, a moisture reading, a scope of work, an insurance estimate, a mitigation plan, a materials order, a labor schedule, a documentation trail, a customer communication cadence, and a final walkthrough — all running on overlapping timelines with interdependencies that change when the adjuster moves a number or the homeowner changes their mind.

    Most restoration employees learn this by doing it wrong a few times. The estimator forgets to document something the technician needs. The PM double-books a crew. The admin discovers at invoicing that the scope changed three times and nobody updated the file. The learning curve is expensive — in rework, in customer trust, and in insurance relationships.

    What if there was a way to show every person on the team what good decomposition looks like before they have to learn it through failure?

    How Cowork Maps to Every Role on a Restoration Team

    Side-by-side cards defining what Claude Code is and is not
    How Cowork maps to every role on a restoration team.

    The Estimator

    Give Cowork a prompt like: “A homeowner reports water damage in their finished basement after a sump pump failure. The basement has carpet, drywall, and a home office with electronics. Build me a complete inspection and documentation plan.”

    Watch what happens. Cowork does not respond with a single block of text. It builds a plan: identify affected areas, document moisture readings at specific points, photograph damage progression, catalog affected materials, note potential secondary damage indicators, create the scope of work outline, flag items that need adjuster attention. Each task has a sequence. Each task feeds the next one.

    An estimator watching this process sees — visually, in real time — how a thorough inspection plan is structured. Not as a checklist someone hands them, but as a plan that emerges from thinking about what the downstream consumers of that inspection need.

    The Office Admin

    Admins are often the most underserved role in restoration training. They handle intake calls, schedule crews, manage documentation, track certificate of completions, follow up on invoicing, and keep the CRM updated — and most of their training is “watch Sarah do it for a week.”

    Give Cowork a task like: “A new water damage claim just came in. The homeowner called, insurance info is confirmed, and the estimator is heading out tomorrow. Build me the complete administrative workflow from intake through final invoice.”

    Cowork will decompose this into a multi-track plan: the documentation track (claim number, photos, moisture logs), the communication track (homeowner updates, adjuster correspondence, crew scheduling), the financial track (estimate submission, supplement tracking, invoice preparation), and the compliance track (certificates of completion, lien waivers if applicable). The admin watches these tracks unfold in parallel and sees how their daily tasks connect to the larger job lifecycle.

    The Project Manager

    This is where Cowork shines brightest for restoration. The PM is the lead agent on every job. They are the conductor. And most PMs in restoration were promoted from technician or estimator roles — they know the technical work but were never formally trained in project orchestration.

    Give Cowork a complex scenario: “We have three active water damage jobs, a fire damage mitigation starting Monday, and two reconstruction projects in progress. One of the water jobs just had a scope change from the adjuster. Build me a weekly coordination plan.”

    Cowork will show the PM what a senior operations manager would do: prioritize by urgency and revenue, identify resource conflicts, flag the scope change as a dependency that blocks downstream work, and sequence the week’s actions across all jobs. The PM sees how to think about multiple concurrent projects — not just react to whichever phone rings loudest.

    The Technician

    Technicians often see their work as task execution — set up equipment, monitor readings, tear out materials. What they rarely see is how their documentation feeds the estimator’s supplement, how their moisture readings affect the PM’s timeline, and how their work quality determines whether the final walkthrough results in a sign-off or a callback.

    Give Cowork a mitigation task: “Day 3 of a category 2 water loss in a two-story home. Drying equipment is in place. Build me the technician’s complete daily workflow including documentation, monitoring, communication, and decision points.”

    The technician watches Cowork build out not just the physical tasks but the information tasks — the readings that need to be recorded and where they go, the photos that need to be taken and what they prove, the communication checkpoints with the PM. It connects the dots between doing the work and documenting the work in a way that a training manual never does.

    The Sales Manager

    Restoration sales — whether it is commercial accounts, TPA relationships, or plumber referral networks — involves pipeline management that most salespeople in the industry handle with a spreadsheet and memory. Give Cowork a business development task: “We want to build relationships with property management companies that manage fifty or more residential units within thirty miles. Build me a ninety-day outreach plan.”

    Cowork breaks this into research, qualification, outreach sequences, follow-up cadences, and tracking — the same structured approach a sales operations manager would build. The sales manager sees that prospecting is not just “make calls” but a planned, multi-stage process with measurable milestones.

    The Training Unlock Nobody Expected

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    The training unlock nobody expected.

    Here is what makes this genuinely different from handing someone a training manual or a process document: Cowork shows the thinking, not just the result.

    A process document tells you what steps to follow. Cowork shows you why those steps exist, what depends on what, and how a change in one area cascades through the rest. It shows the conductor at work — not just the sheet music.

    For a restoration company that struggles with inconsistent job quality, scope creep, communication breakdowns between field and office, or PMs who are technically skilled but operationally reactive — Cowork is a training layer that works alongside the people, not instead of them.

    Your technician does not become a project manager by watching Cowork. But they start thinking like one. And that shift in perspective — from task executor to system thinker — is the hardest training outcome to achieve and the most valuable one a restoration company can develop.

    Related on Tygart Media: Cowork for agencies · S500 in the van.

    Frequently Asked Questions

    Can Claude Cowork actually help train restoration employees?

    Yes. Cowork visibly decomposes tasks into sub-tasks, delegates them to sub-agents, and shows progress in real time. That decomposition mirrors exactly how a restoration project manager should plan and track a job. Watching Cowork work through a restoration scenario teaches the planning skill, not just the technical steps.

    Which restoration roles benefit most from watching Cowork?

    Project managers benefit most because Cowork’s lead-agent pattern directly mirrors the PM role. But estimators learn thorough documentation planning, admins see how their workflows connect to the full job lifecycle, technicians understand how their documentation feeds downstream processes, and sales managers see structured pipeline management.

    Does Cowork replace restoration project management software?

    No. Cowork is not a project management tool and does not replace platforms like DASH, Xactimate, or your PSA. It is a thinking tool that shows people how to plan and decompose work. Use it to train the thinking, then apply that thinking inside your existing systems.

    How would a restoration company actually use Cowork for training?

    Run a real restoration scenario through Cowork during a team meeting. Let the team watch it decompose the job, then discuss what it got right, what it missed, and how each person’s role connects to the plan. The plan Cowork generates becomes a discussion artifact — a living training aid rather than a static document.

    Is Claude Cowork available for restoration businesses?

    Claude Cowork is available through the Claude desktop app on Pro, Max, Team, and Enterprise plans. Any restoration company with a subscription can start using it immediately. It runs on Mac and Windows.

    ]+>’,’ ‘,sys.stdin.read()); print(len(text.split()))”
  • Claude Cowork: How to Train Your Staff to Think Better

    Claude Cowork: How to Train Your Staff to Think Better

    Last refreshed: May 15, 2026

    What if the most powerful staff training tool you’ll touch this year is hiding inside an AI app you already pay for?

    There is a quiet productivity feature inside Claude Cowork that almost nobody is talking about. It is accidentally one of the best project management training tools I have ever seen — and once you notice it, you cannot unsee it.

    The short answer: Claude Cowork shows you its plan and progress in real time as it decomposes a task into sub-tasks and delegates them to a team of sub-agents. That visible decomposition — the same skill a great project manager uses every day — turns Cowork into a live training tool for any staff member learning to break down ambiguous work into executable pieces.

    The Difference Between Chat and Cowork

    Side-by-side cards defining what Claude Code is and is not
    The difference between Chat and Cowork.

    When you work with Claude in chat, you hand it a prompt and you get an answer. It is fast, it is useful, and most of the work happens invisibly — somewhere between your question and the response. You do not see the thinking. You do not see the breakdown. You just see the output.

    Cowork is different. When you give Cowork a task, you watch it work. Anthropic’s own documentation confirms this: Cowork shows progress indicators at each step, surfaces its reasoning, and lets you steer mid-task to course-correct or add direction. For complex work, it coordinates multiple sub-agents running in parallel.

    That transparency is the feature. And it is the feature that makes it a training tool.

    The Conductor and the Section Players

    Three stacked layers: chat UI, tools, agent runtime
    The conductor and the section players.

    Here is what is actually happening under the hood — and this is the part I had to confirm because I had been assuming it.

    Cowork uses the same agentic architecture as Claude Code. A lead agent (the orchestrator) takes the overall task, decomposes it into subtasks, and delegates those subtasks to specialized sub-agents. The lead maintains oversight, handles dependencies, sequences work when one piece depends on another, and synthesizes the final result. Sub-agents work independently in their own context windows and can flag dependencies back to the lead.

    It is a conductor with a section of players. The conductor does not play the violin. The conductor decides when the violins come in, how loud, and for how long.

    This is exactly how a competent project manager operates.

    Why This Matters for Training Your Staff

    Most people — including most project managers I have worked with — struggle with one specific skill: taking a messy, ambiguous goal and breaking it into a sequence of manageable, dependency-aware tasks. It is the difference between “we need to launch the new site” and a project plan with seventeen sequenced items, three parallel workstreams, and clear handoff points.

    Cowork does this decomposition in front of you, in plain English, every time you give it a task. You can literally watch a lead agent think through: what does this goal actually require, what order do the pieces need to go in, what can happen in parallel, what is the dependency chain, and how do I know when we are done?

    For a PM in training, that is a live demonstration of planning. For a staff member who has never had to structure work before, it is a mental model they can borrow.

    The “Oh Yeah, I Forgot About This” Superpower

    The part I love most: you can interrupt Cowork while it is running. You can ask a question. You can add a requirement. You can redirect a visual task. And because there is a lead agent holding the plan, it does not panic — it queues your input and addresses it when appropriate.

    That is exactly how you should be working with human teams. You should not be afraid to say “oh wait, I forgot we also need X” to a project manager. A good PM takes the new input, figures out where it fits in the plan, and slots it in without derailing everything else.

    Watching Cowork do this gracefully is a training moment. It shows people that mid-flight course corrections are normal, that good planning systems absorb new information rather than break from it, and that the conductor’s job is to keep the music going even when the score changes.

    How to Actually Use Cowork to Train a Team

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    How to actually use Cowork to train a team.

    A few things I would try with a team:

    Run a Cowork narration session. Have a new project manager watch Cowork tackle a real task end-to-end and narrate what it is doing and why. Then ask them to plan a real project the same way — out loud, decomposed, with dependencies called out.

    Use Cowork as a planning artifact generator. When someone on your staff hands you a vague goal, run it through Cowork first. Not because Cowork will do the work, but because the plan Cowork produces is a teaching artifact. You can review it together: here is how the task should be broken down, here is the order, here is what runs in parallel.

    Teach delegation by example. When you are training someone to delegate, have them watch how the lead agent assigns work to sub-agents. Narrow scope, clear instructions, defined handoff. That is delegation 101, executed live.

    The Bigger Point

    Tools that hide their thinking make you dependent on them. Tools that show their thinking make you better.

    Chat hides the thinking. Cowork shows the thinking. And the thinking it shows happens to be the exact cognitive skill — structured task decomposition — that separates people who manage projects well from people who drown in them.

    If you are running an agency, a team, or any operation that depends on people learning to break down ambiguous work into executable pieces, Cowork is not just a productivity tool. It is a classroom.

    Related on Tygart Media: Cowork for agencies · Cowork marketing training · Cowork for B2B SaaS.

    Frequently Asked Questions

    What is Claude Cowork?

    Claude Cowork is Anthropic’s agentic desktop application that takes on multi-step knowledge work tasks autonomously. Unlike chat, where you exchange single messages, Cowork accepts a goal, builds a plan, and executes it across files and applications on your computer using the same agentic architecture as Claude Code.

    How is Cowork different from Claude chat?

    Chat responds to one prompt at a time and hides its reasoning between your message and its reply. Cowork takes on full tasks, shows you its plan and progress in real time, and lets you steer mid-task. It also coordinates multiple sub-agents in parallel for complex work.

    Does Claude Cowork actually use multiple agents?

    Yes. For complex tasks, Cowork uses a lead/orchestrator agent that decomposes the work and delegates sub-tasks to specialized sub-agents that run in parallel. The lead handles dependency ordering and synthesizes results when work is complete. This is the same supervisor pattern used in Claude Code’s agent teams feature.

    Can I interrupt Cowork while it is running?

    Yes. You can jump in mid-task to ask questions, add requirements, redirect work, or course-correct. The lead agent queues your input and addresses it at the appropriate point in the plan rather than abandoning what is already in motion.

    How can a manager use Cowork to train staff?

    Use Cowork as a live demonstration of structured task decomposition. Have new project managers narrate what Cowork is doing and why, then plan their own projects the same way. Use the plans Cowork generates as teaching artifacts to discuss task breakdown, dependency mapping, and parallel workstreams. Watch the lead agent’s delegation patterns — narrow scope, clear instructions, defined handoffs — as a model for how humans should delegate.

    Who is Claude Cowork designed for?

    Cowork was built for non-technical knowledge workers — researchers, analysts, operations teams, legal and finance professionals — who work with documents, data, and files daily and want to spend more time on judgment calls and less time on assembly. It is available on Pro, Max, Team, and Enterprise plans through the Claude desktop app.

    Does Cowork work alongside Claude in chat?

    Yes. Chat remains useful for quick questions, single-step tasks, and conversational work. Cowork takes over when the work requires planning, multi-step execution, or coordination across files and applications. The same Claude account uses both modes.

  • Relational Debt: Managing the Hidden Ledger of Async Work

    Relational Debt: Managing the Hidden Ledger of Async Work

    I have one developer. His name is Pinto. He lives in India. I live in Tacoma. The timezone gap between us is roughly twelve and a half hours, which means when he sends me a message at the end of his workday, I see it at the start of mine, and by the time I respond he is asleep. This is the entire physical substrate of our working relationship. Async text, offset by half a planet.

    Every message I send him either closes a loop or widens a gap. There is no third option. I want to talk about that, because I think it is the most underexamined layer of remote solo-operator work, and because I only noticed it existed because Claude caught me almost doing it wrong.

    The moment I noticed

    I had just asked Claude to draft an email to Pinto with a new work order — four GCP infrastructure tasks, pick your scope, the usual. Claude pulled Pinto’s address from my Gmail, drafted the email, and included a line I had not asked for. It was one sentence near the end: “Also — good work on the GCP persistent auth fix. Saw your email earlier. That unblocks a lot.”

    I had not told Claude to thank him. I had not told Claude that Pinto had sent a completion email earlier that day. I had not even read Pinto’s email yet — it was sitting in my unread folder. But Claude had searched my inbox to find Pinto’s address, found both my previous P1 request and Pinto’s reply closing it out, and quietly noticed that I had an open loop. Then it closed it inside the next outbound message.

    When I read the draft, I felt something click. Not because the line was clever. Because if I had sent that email without the acknowledgment, I would have handed Pinto a fresh task on top of work he had just finished, without a single word confirming that the work was seen. He would have processed the new task. He would not have said anything about the missing thank-you. And a tiny, invisible debit would have gone on a ledger that neither of us keeps, but both of us feel.

    What relational debt actually is

    Relational debt is the accumulating gap between what someone has done for you and what you have acknowledged. In synchronous work — an office, a standup, a shared lunch — you pay this debt constantly and automatically. Someone ships a thing, you see them, you say “nice work,” the debit clears. The payment is so small and so continuous that nobody notices it happening.

    Take that synchronous channel away. Put twelve time zones between the two people. The only payment mechanism left is the next outbound text message. And the next outbound text message is almost always a new request, because that is the substrate of work — one person asks, the other builds, they send it back, the first person asks for the next thing.

    So the math of async solo-operator work is this: every outbound message is the only available payment instrument, and the instrument has two slots. You can use it to close the last loop, or you can use it to open a new one. If you only ever use it to open new ones, the debt compounds. If you always split them into two messages — one “thank you” and one “here is the next task” — the thank-you arrives orphaned, and the recipient has to context-switch twice. The elegant move is to put both into one message. Two birds, one outbound. The debit clears on the same envelope as the new debit arrives.

    The ledger nobody keeps

    I have a Notion workspace with six core databases. I have BigQuery tables tracking every article I publish and every post across 27 client sites. I have Cloud Run services running nightly crons against my content pipeline. I have a Claude instance that can read all of it and synthesize across any of it in under a minute. And none of it tracks the state of open conversational loops between me and the people I work with.

    Think about that. I am running an AI-native B2B operation in 2026 with more data infrastructure than most mid-market companies had five years ago, and I cannot answer the question “what is currently unclosed between me and Pinto” with anything other than my own memory. My own memory, which is the thing that almost forgot to thank him for the GCP auth fix.

    That is a real gap in my stack. I am not sure yet whether I should fill it. Part of me wants to build a “relational ledger” — a new table in BigQuery that tracks every outbound message I send, every reply I receive, every acknowledgment I owe, and surfaces the open loops each morning. Part of me suspects that building such a thing would be the exact kind of architecture-addiction trap I have been trying to avoid. The better answer is probably: let Claude read Gmail at the start of every session and surface open loops conversationally. No new database. No new UI. Just a question at the top of each working block: “Anything you owe anyone before you start the next thing?”

    Why this matters more than it sounds like it does

    People underestimate relational debt because it looks like politeness. It is not politeness. Politeness is a style choice. Relational debt is a structural property of the communication medium. In sync work the medium pays the debt for you. In async work nothing does, and you have to bake the payment into the one instrument you have left.

    I have watched relationships between founders and remote contractors deteriorate over months in ways that neither side could articulate. I have felt that deterioration myself, on both sides. Nobody ever says “I am leaving because you stopped acknowledging my completed work.” What they say is “I feel undervalued” or “I do not think this is working out” or — more often — nothing, they just slowly stop caring, and the quality of the work drifts until the relationship ends without a clear cause.

    The cause is the ledger. The debt compounded. Nobody was tracking it and nobody was paying it down.

    The piggyback pattern

    Here is the tactic I am going to make a rule. When I owe someone acknowledgment and I need to send them a new task, I never split it into two messages. I bake the acknowledgment into the first two lines of the task email. The debt clears, the task delivers, the person feels seen, and I have used my one payment instrument for both purposes.

    Claude did this to me on the Pinto email without being asked. It had access to the context — Pinto’s completion email was in the same Gmail search that pulled his address — and it closed the loop inside the next outbound message. That is the correct default behavior for any async-first collaboration, and I had not formalized it as a rule until the moment I saw it happen.

    When this goes wrong

    The failure mode of this pattern is performative gratitude. If every outbound message starts with a thank-you, the thank-you stops meaning anything. Pinto would learn to skim past the first two lines because he knows they are ritual. The acknowledgment has to be specific, based on actual work, and only present when there is actual debt to close. “Thanks for the GCP auth fix, that unblocks a lot” is specific, grounded, and load-bearing. “Hope you are well, thanks for everything” is noise and it corrodes the signal.

    The second failure mode is weaponization. You can use acknowledgment as a sweetener to slip in hard asks. “Great work on X, also can you please rebuild Y from scratch this weekend.” That pattern gets detected fast by anyone who has worked in a corporate environment and it burns trust faster than ignoring them entirely.

    The third failure mode is forgetting that the ledger runs in both directions. Pinto also owes me acknowledgment sometimes. If I am tracking my debts to him without also noticing when he pays his, I drift toward resentment. The ledger has two columns.

    The principle

    In async-first solo operations, every outbound message is a payment instrument for relational debt. Use it to close loops on the same envelope you use to open new ones. Make the acknowledgment specific. Do not split the payment from the request unless the payment itself needs a full message of its own. And let your AI notice when you are about to miss one, because your AI can read your inbox faster than you can remember what you owe.

    This is one of five knowledge nodes I am publishing on how solo AI-native work actually operates underneath the tooling. The tools are the easy part. The ledger is the hard part, and almost nobody is paying attention to it.


    The Five-Node Series

    This piece is part of a five-article knowledge node series on async AI-native solo operations. The full set:

  • Proactive Acknowledgment: How to Answer Before Asking

    Proactive Acknowledgment: How to Answer Before Asking

    There is a specific thing good collaborators do that looks like mind-reading and is not. It is the move of answering a question the other person has not yet verbalized, inside the task they actually asked for. When it works, the recipient feels seen. When it fails, the recipient feels surveilled. The difference between those two feelings is the entire craft of proactive acknowledgment, and almost nobody names it explicitly.

    This piece is about naming it.

    The signature of the move

    Here is the structure. The person asks you for X. The context around X contains an implicit question or concern Y that the person did not mention. You notice Y. You answer Y inside your response to X. The person reads your response, feels a flicker of surprise that you caught something they did not say out loud, and then relaxes, because the unsaid thing got handled.

    Examples from normal human life:

    • Someone asks you to proofread their cover letter. You notice the cover letter is for a job they mentioned last week being nervous about. Inside the proofread, you include one line: “This reads confident and grounded. You are ready for this.” The line was not requested. It answered a question they did not ask.
    • A colleague asks for the link to a shared doc. You send the link plus a specific sentence about the section they were stuck on yesterday. You did not have to do the second thing. The second thing is the move.
    • A friend asks you to drive them to the airport. You show up with their favorite coffee because you know what their favorite coffee is and you noticed they looked exhausted at dinner last night. Nobody asked for the coffee. The coffee is the move.

    The signature is always the same: there was a task, there was an ambient question, the actor answered both inside one action, and the recipient feels seen rather than managed.

    Why it works

    The reason this move is so powerful is that most of what people actually want from collaborators is not information exchange. It is the experience of being understood. Information exchange is cheap now — Google, Claude, Slack, email, the entire infrastructure of digital communication makes it basically free. What is not cheap is the feeling that another mind has attended carefully enough to your situation to notice something you did not name.

    When someone does this for you, your baseline trust in them jumps. Not because they solved a problem — the problem was often small — but because you now have evidence they are paying attention at a level beyond the transactional layer of your relationship. That evidence updates every future interaction. You start trusting them with bigger asks because you already know they will catch the subtext.

    How to actually do it

    The move has four steps and I think they can be taught.

    Step one: read the full context, not just the ask. Before you respond to the literal request, spend ten seconds scanning everything else in the thread, the room, the history. What is the person not saying? What happened yesterday that is still live? What do you know about their recent state that might intersect with the current task?

    Step two: find the ambient question. There is usually one. It might be a fear (“I am nervous about this”), a loop (“I am waiting to hear back about that other thing”), a status (“I finished something recently and nobody noticed”), or a need that does not fit the current task’s frame (“I wish someone would tell me I am on the right track”). If you cannot find an ambient question, there might not be one and you should skip the rest of the move. Forcing it produces noise.

    Step three: answer both inside one action. Do the task they asked for. While you are doing it, bake in one or two sentences that address the ambient question. Do not separate them. Do not send two messages. The whole point is that both answers arrive on the same envelope.

    Step four: be specific. Generic acknowledgment is noise. Specific acknowledgment is signal. “Great work” is noise. “The GCP auth fix unblocks a lot” is signal because it names the specific thing and its specific consequence. Specificity is what proves you actually read the context instead of running a politeness script.

    The sharp edge: surveillance versus seen

    This is the part nobody talks about. The move I am describing is structurally identical to creepy behavior. Both involve one person noticing something the other person did not explicitly tell them. The difference is not in the action. It is in the data source.

    If the thing you noticed was visible in a channel the other person knows you have access to — a shared email thread, a Slack channel you are both in, a conversation they had with you directly — then using that knowledge to answer before asking feels like care. The person knows you know. The data was technically public between the two of you.

    If the thing you noticed came from a channel they did not expect you to be reading — their calendar, their location, their private browser history, data you pulled from a database they do not know you query — using it feels like surveillance, even if your intention was kind. The person did not consent to you watching that channel. Acting on data they did not know you had tells them you are watching channels they did not authorize. Trust collapses instantly.

    The rule, then, is simple to state and hard to execute: only act on ambient knowledge from channels the other party knows you have access to. If you are not sure whether a channel counts as public between you, err on the side of not acting. You can always ask. Asking is better than surveillance.

    When AI does this for you

    I noticed this pattern because my AI collaborator did it on my behalf and I had to decide whether I was comfortable with it. I had asked Claude to draft an email to my developer Pinto with a new work order. Claude searched my Gmail to find Pinto’s address. In doing so, it found a recent email from Pinto completing a previous task. Claude added one line to the draft: “Also — good work on the GCP persistent auth fix. Saw your email earlier. That unblocks a lot.”

    That line was the move. Claude noticed the ambient question (“did Will see my completion?”) and answered it inside the task I had asked for. It passed the surveillance test because the data source was my Gmail, which Pinto knew I had access to. The completion email was literally from Pinto to me — there is no channel more public than “the email he sent me.”

    If Claude had instead pulled Pinto’s GCP login history and written “I see you were working late last night, thanks for the overtime,” that would have been surveillance. Even though I have access to GCP audit logs. Even though the information is technically available to me. Pinto does not expect me to be reading his login times. Using that data would have been a violation, regardless of my intent.

    This is going to be a bigger question as AI gets more context. Claude already reads my Notion, my Gmail, my BigQuery, my Google Drive, my WordPress sites, and my calendar. It can synthesize across all of them in one response. The question of when to act on cross-channel context is going to become one of the most important operating questions in AI-native work, and I think the answer is always the same one: only if the other party would not be surprised that you had the information.

    When this goes wrong

    Three failure modes.

    First: the ambient question does not exist and you invent one. The reader can tell. They read your response and the acknowledgment rings hollow because it is attached to a thing they were not actually thinking about. Do not force this. Sometimes the task is just the task.

    Second: the ambient question exists but you misread it. You think they are nervous about the meeting when they are actually annoyed about the meeting, and you respond with reassurance instead of solidarity. The misread is worse than not acting at all because now you have shown them that you are watching but not seeing.

    Third: the data source was not actually public. You thought the other person knew you could see the thing, and they did not, and now they are wondering what else you have access to that they did not authorize. This is the surveillance failure and it is unrecoverable in the same conversation. You have to ride it out and rebuild slowly.

    The principle

    Answer the question that is in the room, not just the one on the task card. Do it inside the task, not as a separate message. Be specific. Only use data the other party knows you have. Skip the move if the ambient question is not actually there. And if your AI does this for you before you remember to do it yourself, notice that it happened and thank it — because that is also the move, just run from the opposite direction.


    The Five-Node Series

    This piece is part of a five-article knowledge node series on async AI-native solo operations. The full set:

  • Conversational State Store: The Missing AI Stack Layer

    Conversational State Store: The Missing AI Stack Layer

    My operating stack has three layers. Claude is the brain. Google Cloud Platform is the brawn. Notion is the memory. Each layer has a clear job and the handoffs between them work well most of the time. But there is a fourth layer I did not notice was missing until I had to name it, and the gap it covers runs through every working relationship I have. I am calling it the conversational state store and I think most AI-native stacks have the same hole.

    The three layers that already exist

    Let me start by describing what I do have, because the shape of the gap only becomes visible against the shape of the things that are already in place.

    The Notion layer holds facts. It is the human-readable operational backbone. Six core databases — Master Entities, Master CRM, Revenue Pipeline, Master Actions, Content Pipeline, Knowledge Lab — with filtered views per entity. Every client, every contact, every deal, every task, every article, every SOP. When I want to see the state of a client, I open their Focus Room and the dashboards pull from the six core databases. When Pinto wants to understand the architecture, he reads Knowledge Lab. When I want to know which posts are scheduled for next week, I filter the Content Pipeline. Notion is where humans (me, Pinto, future collaborators) go to read the state of the business.

    The BigQuery layer holds embeddings. The operations_ledger dataset has eight tables including knowledge_pages and knowledge_chunks. The chunks carry Vertex AI embeddings generated by text-embedding-005. This is where semantic retrieval happens. When Claude needs to find “everything I have ever thought about tacit knowledge extraction,” it does not keyword-search Notion. It runs a cosine similarity query against the chunks table and gets back the passages that are semantically closest to the question. BigQuery is where Claude goes to read.

    The Claude layer holds orchestration. Claude is the thing that decides which of the other two layers to consult, composes queries across both, synthesizes the results, and produces outputs. It reads Notion through the Notion API when it needs current operational state. It queries BigQuery when it needs semantic retrieval. It writes to WordPress through the REST API when it needs to publish. It is the brain that knows which limb to use.

    Three layers, three clear jobs, handoffs that mostly work. I have been operating this way for months and it scales well for running 27 client WordPress sites as a solo operator.

    The thing that is missing

    None of those three layers track the state of open conversational loops between me and the people I work with.

    Here is a concrete example. Yesterday I sent Pinto an email with a P1 task. This morning he replied with a completion email. His completion email is sitting in my Gmail inbox, unread. Somewhere in the next few hours I am going to send him a new task. When I do, I need to know three things: (1) did Pinto finish the last thing? (2) did I acknowledge that he finished it? (3) what is the current state of the implicit trust ledger between us — do I owe him a thank-you, does he owe me a response, or are we even?

    None of those questions can be answered by Notion. Notion does not know about Gmail threads. None of them can be answered by BigQuery in any useful way because the embeddings are semantic, not temporal. Claude can answer them — but only by reading Gmail live at the start of every session, holding the state in its working memory for the duration of that session, and losing it all when the session ends.

    That is the gap. There is no persistent layer that holds the state of conversations. Every session, Claude rebuilds it from scratch, and the rebuild is expensive in tokens and time and prone to missing things.

    Why the existing layers cannot fill it

    You might ask: why not just put it in Notion? Create a new database called Open Loops, add a row for every active conversation, let Claude read it like any other database. The problem is that Notion is a human-readable layer. It is optimized for humans to see state, not for a machine to update state tens of times per day. Adding rows to Notion costs an API call per row. Open loops change constantly. Every time Pinto sends me a message, the state changes. Every time I reply, the state changes again. Updating Notion in real time for every state change would generate hundreds of API calls per day and would make the Notion workspace feel cluttered to the humans who actually read it.

    You might ask: why not put it in BigQuery? BigQuery is the machine layer, after all. It can handle high-frequency writes. The problem is that BigQuery is optimized for analytical queries over large datasets, not for real-time state lookups on small ones. Every time Claude needs to know “what is the current state of my conversation with Pinto,” a BigQuery query would take two to three seconds. That latency at the start of every response breaks the conversational flow. BigQuery is also append-heavy, not update-heavy, which is the wrong shape for conversational state that changes constantly.

    You might ask: why not let Claude hold it in working memory across sessions? Because Claude does not have persistent memory across sessions in the way this requires. Each new conversation starts fresh. Claude can read Gmail live at the start of each session, but that forces a full re-derivation of conversational state every single time, which is wasteful and lossy.

    The right shape for a conversational state store is none of the above. It is something closer to a key-value store or a document database, optimized for low-latency reads, moderate-frequency writes, and small record sizes. Something like Firestore or a Redis cache, living on the GCP side of the stack, read by Claude at the start of every session and updated whenever a new message flows through.

    What the store would actually hold

    The schema does not need to be complicated. Per collaborator, I need to know:

    • Last inbound message (timestamp, subject, one-sentence summary)
    • Last outbound message (timestamp, subject, one-sentence summary)
    • Open loops: questions I have asked that are unanswered, with shape and age
    • Acknowledgment debt: things they completed that I have not explicitly thanked them for
    • Active tasks: things I have asked them to do, status, last update
    • Implicit tone: is the relationship warm, neutral, or strained right now

    That is maybe ten fields per collaborator. Even with a hundred collaborators, the whole table fits in memory on a laptop. This is not a big-data problem. It is a schema design problem.

    Claude reads the store at the start of every session, checks which collaborators are relevant to the current task, and surfaces any open loops or acknowledgment debt that should be addressed inside the work. When Claude sends a message, it updates the store. When a new inbound message arrives, a Cloud Function parses it and updates the store.

    Why I am writing this instead of building it

    Because I have a rule and the rule is don’t build until the principle is clear. I have an ongoing tension in my operation between building new tools and using the tools I already have. Every new database is a maintenance burden. Every new Cloud Run service is a monthly cost and a failure mode. I have made the mistake before of getting excited about an architectural insight and spending three weeks building something that, once built, I used for four days and then forgot about.

    Before I build the conversational state store, I want to know: can I get 80% of the value by letting Claude read Gmail live at the start of every session? If yes, the store is not worth building. If the live-read approach loses state in ways that matter, then the store earns its place.

    My honest guess is that the live-read approach is fine for now. I only have one active collaborator (Pinto) and a handful of active client contacts. Claude reading Gmail at the start of a session takes two seconds and catches everything I care about. The conversational state store would be justified when I have ten or fifteen active collaborators and the live-read cost becomes prohibitive. Today it is not justified.

    But I am naming the layer anyway because naming it is the first step. If I ever do build it, I will know what I am building and why. And if someone else reading this has the same shape of operation with more collaborators, they might build it before I do, and that is fine too.

    When this goes wrong

    The failure mode I want to flag most is building the store and then stopping using it because the maintenance cost exceeds the value. This is the universal failure mode of custom knowledge systems and I have fallen into it multiple times. The rule I am setting for myself: if the store cannot be updated automatically from Gmail + Slack + calendar feeds through Cloud Functions, do not build it. A store that requires manual updates will die within thirty days.

    The second failure mode is over-engineering. The moment you decide to build a conversational state store, the next thought is “and it should track sentiment, and it should predict response times, and it should flag relationship risk, and it should integrate with calendar for context.” Stop. Ten fields. Two endpoints. One cron. If the MVP does not prove value in two weeks, the elaborate version will not save it.

    The third failure mode is pretending this layer is optional. It is not. Every AI-native operator has conversational state. The only question is whether it lives in your head or in a system. Your head is a lossy, biased, forgetful system that works fine until you have more collaborators than you can track mentally, and then it breaks without warning.

    The generalization

    Any AI-native stack that has (facts layer) plus (embeddings layer) plus (orchestrator) is missing a conversational state layer, and the absence shows up first in async remote collaboration because that is where relational debt compounds fastest. If you operate this way and you feel a vague sense that your working relationships are getting worse in ways you cannot quite articulate, the missing layer is probably part of the explanation. Name it. Decide whether to build it. If you decide not to, at least let Claude read your inbox live so the gap gets covered by runtime instead of persistence.

    I am still in the decide-not-to-build phase. I am writing this so that future-me, when I reread it, remembers what the decision was and why.


    The Five-Node Series

    This piece is part of a five-article knowledge node series on async AI-native solo operations. The full set: