On February 2, 2026, Anthropic announced research partnerships with two of the most rigorous scientific institutions in the world: the Allen Institute (founded by Paul Allen, focused on neuroscience, cell science, and AI) and the Howard Hughes Medical Institute (HHMI, which funds more than 300 of the world’s leading biomedical researchers). Both are founding partners in what Anthropic is building as Claude’s life sciences research capability.
This is the most underreported significant Anthropic story of 2026. While Claude Security and the Partner Network grabbed headlines, Anthropic quietly signed partnerships with institutions that are generating some of the most important biological data in human history. Here is what is actually being built.
The Problem Claude Is Solving in Elite Labs
The problem Claude is solving in elite labs.
Modern biological research generates data at unprecedented scale. Single-cell RNA sequencing produces gene expression profiles for thousands of individual cells simultaneously. Whole-brain connectomics generates petabytes of neural connectivity data. Protein structure prediction now runs continuously on entire proteomes. The data generation problem has been largely solved by computational advances over the last decade.
The bottleneck that has not been solved is what comes next: transforming data into validated biological insights. Knowledge synthesis — reviewing literature, connecting experimental results to existing findings, generating hypotheses, and designing follow-up experiments — still depends almost entirely on manual human processes. In elite labs, this bottleneck can stretch research timelines from months to years.
A single-cell sequencing experiment might produce 50,000 cells worth of gene expression data in a week. Making sense of that data in the context of existing biological knowledge, generating testable hypotheses, and designing the right follow-up experiments might take a postdoc six months of literature review and analysis. That ratio — days of data generation, months of interpretation — is where Claude-powered multi-agent systems are being applied.
What the Allen Institute Is Building
What the Allen Institute is building.
The Allen Institute collaboration focuses on multi-agent AI systems for multi-modal data analysis. “Multi-modal” in this context means data types that span imaging, sequencing, electrophysiology, and behavioral observation — the full range of data types generated in modern neuroscience and cell science research. Claude-powered agents are being integrated with the Allen Institute’s existing analysis pipelines and scientific instruments.
The specific capability being built: agents that can hold the entire context of an ongoing research project — experimental history, current data, relevant literature, open hypotheses — and surface connections that human researchers would not make simply because no single human can hold that much context simultaneously. The agent serves as a comprehensive knowledge base integrated with cutting-edge instruments, not a search engine or literature summarizer.
The HHMI Partnership
Howard Hughes Medical Institute funds 300+ Investigators — researchers selected through a rigorous competitive process as among the most promising scientists in their fields. HHMI’s partnership with Anthropic focuses on deploying Claude-powered AI agents to tackle the analysis, annotation, and coordination bottlenecks that are consuming researcher time at the expense of the creative scientific work that only humans can do.
The framing Anthropic uses for this partnership is important: Claude should augment, not replace, human scientific judgment. The reasoning that Claude surfaces needs to be traceable — researchers must be able to evaluate, question, and build upon Claude’s outputs. This is a different design requirement than a consumer AI assistant. In science, an AI that produces correct-sounding but untraceable conclusions is worse than no AI at all, because it introduces unverifiable claims into the research record.
Why This Matters Beyond Biology
Why this matters beyond biology.
The Allen Institute and HHMI partnerships are significant beyond their direct scientific impact for two reasons:
They establish Claude’s capability floor in high-stakes reasoning environments. These institutions have no tolerance for AI that produces plausible-sounding incorrect answers. If Claude is being used in production at the Allen Institute and HHMI, it has cleared a rigor bar that most AI products have not. That is a capability signal.
They create a template for other scientific domains. The multi-agent architecture being built for neuroscience and cell biology is applicable to drug discovery, climate science, materials science, and astrophysics. The bottleneck pattern — fast data generation, slow knowledge synthesis — exists across all of science. The Allen Institute and HHMI implementations are the proof-of-concept Anthropic can show to the next set of research institutions.
Anthropic’s scientific AI partnerships sit at the intersection of its commercial strategy and its stated mission. If Claude-powered agents can meaningfully accelerate biological research — reducing the time from data to insight from months to weeks — the downstream impact on medicine and human health is the kind of outcome that makes the safety-focused AI development approach Anthropic argues for feel less abstract.
Current flagship: Claude Opus 4.7 (claude-opus-4-7). Current models: Opus 4.7 · Sonnet 4.6 · Haiku 4.5. Claude Opus 4.7 referenced in this article has been superseded. See current model tracker →
On December 3, 2025, Snowflake and Anthropic announced a multi-year, $200 million partnership making Claude models available to Snowflake’s 12,600+ global enterprise customers across AWS, Azure, and Google Cloud. If you are running data infrastructure on Snowflake — which means you are in the company of most Fortune 500 financial services, healthcare, and technology organizations — Claude is now a first-class capability inside your existing data environment.
This partnership was not widely covered when it launched, and it has not been covered at the depth it deserves. Here is the complete picture of what was built and why it matters.
Snowflake Intelligence: What It Is
Snowflake Intelligence — what it is.
Snowflake Intelligence is an enterprise intelligence agent powered by Claude Sonnet 4.6 (the model at launch; check Snowflake’s current docs for the latest). It answers natural language questions about your organization’s data by: determining what data is needed, querying across your entire Snowflake environment, joining data from multiple sources, and delivering answers with greater than 90% accuracy on complex text-to-SQL tasks in Snowflake’s internal benchmarks.
The “greater than 90% accuracy on complex text-to-SQL” claim is the number that matters. Text-to-SQL accuracy has historically been the failure mode for natural language data querying — ambiguous column names, complex join logic, and domain-specific terminology conspire to make AI-generated SQL unreliable without significant prompt engineering and validation. Snowflake’s 90%+ benchmark on complex queries (not simple ones) represents a meaningful improvement over prior-generation approaches.
Snowflake Cortex AI Functions
Beyond the intelligence agent, Snowflake Cortex AI Functions expose Claude Opus 4.5 and newer models directly within Snowflake’s SQL environment. You can call Claude from a SQL query — pass a column of text to Claude for classification, summarization, sentiment analysis, or extraction, and receive structured results back as a query output. No API calls, no external services, no data leaving your Snowflake governance boundary.
This is a fundamental shift in how AI is applied to enterprise data. Instead of extracting data from Snowflake, sending it to an external AI service, and loading results back, AI reasoning happens inside the governance boundary where the data lives. For regulated industries — financial services under SOX, healthcare under HIPAA, government under FedRAMP — this is the architectural difference between a compliant AI workflow and one that requires a data transfer agreement.
Why Regulated Industries Move to Production Faster
Why regulated industries move to production faster.
The specific value proposition Snowflake and Anthropic built this partnership around is the regulated industry path from pilot to production. The two primary blockers for enterprise AI in regulated industries have historically been:
Data governance. Sensitive data cannot leave governed environments. Solutions that require sending data to external APIs fail compliance reviews. Cortex AI Functions solve this by keeping Claude within the Snowflake perimeter.
Accuracy and auditability. A financial services firm cannot deploy a customer-facing AI tool that is wrong 20% of the time and cannot explain its reasoning. Claude’s documented reasoning capability and Snowflake’s query audit trail together create an auditable AI chain that compliance teams can review.
The 12,600 Snowflake customers who now have access to Claude through this partnership include organizations in financial services, healthcare, life sciences, manufacturing, and technology — precisely the sectors where AI adoption has been slowest due to compliance barriers. The Snowflake perimeter solves barrier #1. Claude’s accuracy and reasoning capability addresses barrier #2.
Practical Steps for Snowflake Customers
Practical steps for Snowflake customers.
If you are a Snowflake customer and have not activated Cortex AI Functions:
Check your Snowflake account tier — Cortex AI Functions require Business Critical or Enterprise edition.
Enable Cortex in your account settings. No additional Anthropic API key is required — the Claude models are accessed through Snowflake’s compute layer.
Start with a bounded use case: classify a column of customer feedback into categories, extract structured fields from unstructured text, or generate summaries of long documents stored as Snowflake objects.
Use Snowflake Intelligence for stakeholder-facing natural language querying once your Cortex implementation is validated.
Two new Claude Code capabilities shipped in the April sprint that have received almost no coverage despite being significant workflow expansions: Ultraplan, a cloud-hosted agentic planning workflow, and Ultrareview, a deep multi-pass code review command. Together they represent Claude Code’s first serious steps toward being an agentic planning tool, not just an interactive coding assistant.
Ultraplan: Cloud-Hosted Agentic Planning
Ultraplan — cloud-hosted agentic planning.
Ultraplan is currently in early preview. The workflow is three steps:
Draft in the CLI — from your terminal, describe the task or project you want Claude Code to plan. Ultraplan generates a structured execution plan: steps, dependencies, tool calls, expected outputs, error-handling branches.
Review in the browser — the plan is pushed to a cloud-hosted web editor where you can read it in a structured interface, add comments, modify steps, flag concerns, and approve or reject sections. This is the human-in-the-loop gate that makes agentic execution trustworthy.
Run remotely or pull back local — once approved, the plan can execute in Anthropic’s cloud infrastructure (no local machine required, runs while your laptop is off) or be pulled back to execute locally with full observability in your terminal.
The remote execution capability is the most significant aspect. This is Claude Code’s first “runs while your laptop is closed” feature — distinct from Cowork Routines (which are consumer-facing) and designed specifically for developer workflows. A migration plan, a batch refactoring job, a test suite generation task, or a dependency upgrade across a large codebase can be approved, handed to cloud execution, and completed overnight without a machine staying on.
When to Use Ultraplan
When to use Ultraplan.
Ultraplan is designed for tasks where you want to review the approach before committing to execution — not for quick, single-step tasks. The review step adds 5–15 minutes to the workflow. That is worth it when:
The task spans multiple files, services, or systems where a wrong step has cascading effects
You are working in a production codebase where mistakes have real consequences
The task will take more than 30 minutes to execute and you want human review before investing that time
You are using remote execution and cannot monitor progress in real time
You are delegating the task to a junior developer or teammate who will execute the plan
For quick tasks — generate a function, fix a specific bug, explain this code — use standard Claude Code. Ultraplan’s value scales with task complexity and execution risk.
Ultrareview: Deep Multi-Pass Code Review
Ultrareview — deep multi-pass code review.
The claude ultrareview subcommand applies multiple sequential review passes to code, each with a different evaluation focus:
Maintainability review — naming clarity, function size and cohesion, documentation gaps, test coverage, coupling and cohesion
Each pass generates findings, and Ultrareview synthesizes them into a prioritized report with severity ratings and specific remediation recommendations. The output is designed to go directly into a pull request review comment or a team review document.
Ultrareview vs. Standard Review
Standard claude review applies a single review pass optimized for breadth — it catches obvious issues quickly across all dimensions. Ultrareview applies specialized depth in each dimension sequentially. The trade-off is token cost and time: Ultrareview consumes 3–5× more tokens than standard review and takes proportionally longer.
The recommended workflow: use standard review on every pull request as part of your CI pipeline. Reserve Ultrareview for high-stakes merges — releases, security-sensitive features, architecture changes, any code that will touch production payment or authentication flows.
Both features are available now to Claude Code users on Pro and above. Ultraplan is in early preview — activate it via claude ultraplan --enable-preview. Ultrareview is generally available — run claude ultrareview [file or directory] from any Claude Code session.
Claude Code shipped v2.1.126 today, May 1, 2026. This is the 9th release in April’s sprint and continues what has been a 2–3 releases per week cadence throughout the month. Here is the complete picture of what shipped this week across v2.1.120 through v2.1.126, with operational context for each feature that actually matters.
v2.1.126 — Today’s Release
v2.1.126 — today’s release.
Gateway Model Picker
The gateway model picker allows you to route different tasks within a single Claude Code session to different models. This is the first step toward Claude Code as a multi-model orchestration layer rather than a single-model coding assistant. Practical use: run Haiku 4.5 on file reading, search, and summarization tasks where speed matters; route Opus 4.7 at complex reasoning, architecture decisions, and code generation where quality is the priority. The cost reduction on high-volume workflows can be material — Haiku is roughly 30× cheaper per token than Opus.
PowerShell as Primary Shell on Windows — Git Bash No Longer Required
This is the most significant quality-of-life change in this release for enterprise Windows shops. Claude Code previously required Git Bash as its terminal environment on Windows, which meant every Windows developer needed a non-standard shell installation, created friction in corporate IT environments with software approval processes, and produced a different developer experience than Mac/Linux teammates.
Starting with v2.1.126, PowerShell is the primary shell on Windows. Git Bash is no longer required. For enterprise teams where half the developer fleet runs Windows and software installation requires IT approval, this removes a significant deployment barrier. Claude Code is now a standard Windows application from an IT management perspective.
OAuth Code Terminal Input for WSL2, SSH, and Containers
Authentication in headless environments — WSL2 sessions, SSH remote development, Docker containers — previously required workarounds. v2.1.126 adds OAuth code terminal input: Claude Code displays the authorization code directly in the terminal, you paste it into your browser, and authentication completes without requiring a browser redirect to the headless environment. Eliminates the most common authentication friction point for remote and containerized development workflows.
claude project purge
New command that cleans up stale project data accumulated across sessions. For teams running Claude Code in CI/CD pipelines or long-running agent workflows, project data can accumulate and affect performance. claude project purge gives you explicit control over that cleanup rather than relying on automatic garbage collection.
v2.1.120–122 — April 28 Stack
v2.1.120–122 — April 28 stack.
alwaysLoad MCP Option
MCP servers can now be configured to always load regardless of context window state. Previously, Claude Code would make decisions about which MCP servers to initialize based on available context. alwaysLoad: true in your MCP server config guarantees that server is always available — critical for production deployments where MCP tools need to be reliably present, not conditionally loaded.
claude ultrareview Subcommand
claude ultrareview triggers a deep, multi-pass code review that goes beyond standard review. It applies multiple review personas in sequence — security researcher, performance engineer, maintainability analyst — and synthesizes findings into a prioritized report. For code that needs to meet high standards before production merge, ultrareview is the command. It consumes more tokens than standard review, so use it on pull requests that matter, not every commit.
claude plugin prune
Removes unused plugins from your Claude Code installation. As the plugin ecosystem has grown and plugin auto-update behavior has been refined in recent releases, teams accumulate plugins that are no longer active in their workflow. claude plugin prune audits your installed plugins against recent usage and removes those that have not been invoked within a configurable time window.
Type-to-Filter Skills Search
The skills picker now supports live type-to-filter — start typing a skill name and the list filters in real time. For teams with large skill libraries or plugin collections, this eliminates the scroll-and-hunt workflow that slowed skill invocation. Small UX change, large daily time savings at scale.
New environment variable that allows Claude Code running on Amazon Bedrock to specify service tier at the environment level rather than per-request. For teams using Claude Code through Bedrock as their primary deployment path — common in regulated industries that require AWS-native infrastructure — this simplifies configuration management across multiple environments and removes per-request overhead.
OpenTelemetry Improvements
Extended OpenTelemetry trace data now includes more granular span information for Claude Code operations. For enterprise teams with existing observability infrastructure (Datadog, Grafana, Honeycomb), Claude Code activity is now more fully integrated into your trace timeline — you can see exactly where Claude Code operations land within the context of your broader application traces.
v2.1.123 — April 29
Fixed OAuth 401 retry loop triggered when CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS was set. If you were seeing repeated authentication failures in environments with that flag set, update to v2.1.123 or later immediately.
Update Now
Update now.
Update via npm install -g @anthropic-ai/claude-code@latest or through your package manager. v2.1.126 is the current stable release. For teams running Claude Code in CI/CD, update your Docker base images or pipeline steps to pin to 2.1.126.
This article was not written by a scheduled task. It was not part of a batch pipeline. There was no cron job, no Cloud Run trigger, no automation queue. I asked Claude in chat, we picked an angle, I generated the images myself, and Claude hand-crafted what you are reading now. Custom, batch-of-one, at the desk. I’m leading with that because it is the entire point of the piece.
On April 22, Google Cloud Next ’26 turned Vertex AI into something else. The keynote rebranded it as the Gemini Enterprise Agent Platform. The new pieces are an Agent Designer, an Agent Inbox, long-running agents that can work autonomously for days inside cloud sandboxes, and Agent Observability, Agent Simulation, Agent Identity, Agent Registry. Google framed agents as managed enterprise workloads with identity, policy, observability, evaluation, and runtime controls, rather than one-off AI applications. They added Anthropic’s Claude Opus 4.7 to the Model Garden alongside Gemini 3.1. They committed $750 million to a partner program to push it through Accenture, Salesforce, SAP, and Deloitte.
That announcement is the most architecturally ambitious version of agentic infrastructure anyone has shipped. It is also enterprise-shaped, not operator-shaped. The customers in the keynote were Walmart, Citadel, Honeywell, Home Depot, Papa John’s. The framing was Agentic Enterprise. The unit of trust was a partner integrator. None of that is a criticism. It is just a different scale of problem than the one a sole operator running 20+ WordPress sites and a content automation stack actually has.
What Google announced is what we already built — at our scale
Underneath the marketing, Gemini Enterprise Agent Platform answers one specific question: how do you give an autonomous system enough leash to be useful, while keeping enough control to catch it when it fails? Google’s answer involves Agent Identity, runtime policy enforcement, observability dashboards, and evaluation harnesses. It is the right answer. It is also the answer we landed on — independently, six months earlier, at a much smaller scale — because the question is the same whether you are running a Fortune 50 supply chain or a one-person agency that publishes 200 articles a month.
Tier-gated autonomy: amber proposes and waits for approval, blue prepares but never publishes, green runs autonomously and reports anomalies.
Our version is called The Bridge. It is a top-level page in our Notion workspace, peer to the operations Command Center. Underneath it lives the Promotion Ledger, where every autonomous behavior in our stack is tracked by tier and status. Tiers are A, B, C, and Wings. Status is one of Running, Probation, Demoted, Candidate, Graduated, or Retired. The Pane of Glass is the live Cowork artifact view of the whole thing. It is the operator-scale equivalent of Google’s Agent Inbox, except it is not selling itself to me — it is reporting to me.
The three tiers, in plain language
Tier A — System proposes, operator approves. A behavior at this tier produces a recommendation, not an action. Claude flags an opportunity, drafts a structure, surfaces a candidate. I make the call. Approval happens through an elevated report, not an atomic checkbox queue. This is where everything new starts.
Tier B — Operator flies it, system prepares. The behavior is allowed to do all the preparatory work — research, drafting, formatting, staging — but the publish button stays under my hand. This is where most behaviors live for a while. Most of the trust gap is closed at Tier B because I can see exactly what the system would have done before it does it.
Tier C — System runs autonomously, reports anomalies. The behavior publishes, posts, files, schedules — without asking. It only surfaces in my inbox when something is off. The twice-daily software update monitoring pipeline that writes posts to The Machine Room category on this site is Tier C. So is the weekly digest that drafts the LinkedIn and Facebook posts off it. I do not see those running. I see them only when they fail to run.
Wings is a fourth tier — used for behaviors that are still on the candidate list, where the architecture exists but the trust does not yet.
The clock that makes it work
Promotions are not a feeling. They are a count. Seven clean days at a tier makes a behavior a candidate for promotion to the next. Any gate failure resets that clock to zero and drops the behavior down one tier. The failure is logged on the Promotion Ledger row with date and reason. Decisions to promote or demote happen on Sunday evenings — not in the middle of a panic on a Tuesday.
This is the part that most “AI agent governance” frameworks skip. They define the tiers but not the promotion mechanic. Without the clock, every promotion is a vibe call. With the clock, the question stops being do I trust this agent and becomes what does the ledger say. The answer is either there or it is not.
Trust as evidence. The Promotion Ledger reads clean — or it does not. Reassurance is not a substitute for a number on a row.
Why this article is hand-crafted, on purpose
Here is the meta-move that makes the framework legible. The system that publishes most of our content is Tier C Running — twice-daily monitoring writes posts directly to The Machine Room and Industry Signals categories without my approval, and the weekly digest drafts the social. That works because the behavior has earned its leash on the ledger.
This article is not that. This article is a one-off, custom request, hand-crafted in chat. I asked Claude what it thought of the Next ’26 announcements relative to our stack. We had a real exchange about it. I generated four sets of images on my own, picked the directions, and let Claude pick the strongest variants from each set. We agreed on the angle. Then I gave one explicit, in-conversation authorization to publish live to WordPress and LinkedIn — because publishing to LinkedIn live is not a Tier C Running behavior on the ledger right now, and the system correctly flagged that gap and asked.
That is the whole framework, working in real time. The twice-daily Tier C automation does not need to ask. The one-off LinkedIn live publish does need to ask. The system knows the difference because the difference is on a Notion page, not in a vibe.
What Google’s announcement actually changes for operators like us
Three things, all useful.
The vocabulary went mainstream. “Long-running agents,” “Agent Inbox,” “agent governance,” “agent observability” — these are now words you can say to a CFO without translating. The bar for trust-gap evidence just went up across the field, which means the operators who already have a ledger are ahead of the operators who have a vibe. Stay on the ledger.
Claude is in the Model Garden. If we ever want to run our Cowork-style behaviors inside Google’s agent runtime — using their identity, observability, and governance plumbing while keeping Claude as the model — that door is now open. We will not, because the platform overhead is more than we need. But the option being available is structurally significant.
The architectural pattern is validated. When the third-largest cloud spends a keynote arguing that agents need tier-style governance and an inbox-style observability layer, every operator running an autonomous stack should treat that as confirmation, not as a sales pitch. We are not the weird ones for running a Promotion Ledger. We were just early.
The unsexy part
The unsexy part of all of this is that none of it works without the boring discipline of writing things down. The tiers are useful because they are on a page. The promotion clock is useful because it is a number. The trust-gap protocol is useful because it points to evidence rather than to feelings. Google is building the same thing for the Fortune 500 because the discipline is the same at every scale. The only thing that changes is whether you call it a Promotion Ledger or an Agent Registry.
Build the ledger. Run the clock. Publish what is earned. Ask before you do what is not. The rest is just whose dashboard is prettier.
The conversation no one in restoration is having yet
The conversation no one in restoration is having yet.
The most consequential shift in restoration economics over the next thirty-six months is also the topic that almost no one in the industry is discussing in any operational depth. The shift is the cost structure that emerges when a meaningful share of a restoration company’s operational work is done by AI agents running on managed infrastructure rather than by human staff or by traditional software.
The shift is not coming. It is here. The early-adopter companies have been operating in this cost structure for the last twelve months, and the second wave is coming online now. By the end of 2026, a competitive baseline will exist for what an AI-augmented restoration company looks like financially, and companies operating outside that baseline will start to feel the difference in their bid competitiveness, their margin profile, and their ability to take on growth.
This article is about the economics of that shift. The math is not complicated. The implications are large.
What an agent-assisted operation actually costs
What an agent-assisted operation actually costs.
Start with the cost of running a meaningful AI agent capability inside a restoration company in 2026. The cost has three components.
The first is the model usage cost. This is what gets paid to the AI provider for the actual inference — the tokens consumed, the requests made, the work the model does on the company’s behalf. For most restoration use cases, model usage cost runs in the range of a few cents per significant operation. A handoff briefing generation. A scope review pass. A photo organization run. A communication draft. Each of these costs pennies.
The second is the runtime cost when agents are executing autonomously rather than producing single outputs on demand. An agent that runs a multi-step task — pulling a file, organizing the documentation, generating the briefing, packaging it for the rebuild team — incurs runtime cost for the duration of its session. For restoration use cases, even complex agent sessions tend to cost low single digits of dollars at most.
The third is the operational cost of the human owners and reviewers. The senior operator who owns the AI capability. The person who reviews the outputs and feeds back corrections. The person who maintains the prompts and configurations. This is the largest of the three components by a wide margin and is often the only one that owners explicitly account for, because it is the one that shows up on payroll rather than on a separate line item.
The total cost per operation, when honestly accounted for, is meaningful but small. The economic significance comes not from the per-operation cost but from the volume.
The volume changes everything
A traditional restoration operation has a defined operational throughput per senior operator. A senior project manager can credibly run a certain number of jobs per month. A senior estimator can scope a certain number of files per week. A senior dispatcher can coordinate a certain number of mitigation responses per day. These throughput numbers are determined by the human operator’s working capacity and have not meaningfully changed in decades.
An agent-assisted operation has fundamentally different throughput characteristics for the work the agents handle. A handoff briefing generation that takes a human operator twenty minutes can be produced by an agent in under a minute. A scope review pass that takes a human estimator forty-five minutes can be produced by an agent in three minutes. A photo organization that takes a human technician thirty minutes can be done by an agent in ninety seconds. The human is still in the loop — reviewing, validating, correcting — but the operator is reviewing the agent’s output rather than producing the original work.
The economic implication is that a senior operator’s throughput on documentation and review work expands by a multiple. Not by ten percent or twenty percent. By a multiple. A senior estimator who previously could handle thirty files per week can, with appropriate agent assistance and a working review workflow, handle eighty or a hundred files per week, with comparable or improved quality, depending on the file mix and the maturity of the agent capability.
The cost of the agent capability supporting that estimator runs in the range of a few hundred dollars per month. The value of the additional throughput is in the tens of thousands of dollars per month at typical estimator productivity rates. The ratio is severe enough that the economics dominate the conversation about whether to invest, regardless of how the implementation cost is amortized.
What this does to bid competitiveness
The cost structure shift has direct implications for what restoration companies can afford to bid on competitive work.
A company running on traditional throughput economics has a certain unavoidable cost per job that includes the senior operator time required to produce the documentation, scope, communication, and review work the job requires. That cost sets a floor on the bid. Below that floor, the company loses money.
A company running on agent-assisted throughput economics has a meaningfully lower floor on the senior operator time required per job. The same senior team can be spread across more jobs without quality degradation, because the routine work has been compressed by orders of magnitude. The floor on what the company can profitably bid drops.
For the company doing the bidding, this looks like the ability to win more work at price points that previously would have been unprofitable. For the company being out-bid, this looks like an inexplicable competitive pressure where peers are taking work at numbers that should not pencil. The traditional company looks at the same numbers and assumes the competitor is buying market share unprofitably or providing inferior service. In the early days of the shift, that assumption is sometimes true. Within twelve to eighteen months it stops being true. The competitor is not buying market share. Their cost structure has shifted.
Companies that have not made the shift cannot match the bid without unacceptable margin compression. They start losing work at the margins of their territory, and the lost work is the most price-sensitive work, which means the work they are still winning is increasingly the high-touch, complex, strategically important work — which sounds fine until they realize they have lost the volume layer that used to fund their fixed overhead.
What this does to growth capacity
The same shift changes what growth looks like for a restoration company.
In a traditional operation, growth is gated by the company’s ability to add senior operational capacity. New service lines, new geographies, new account relationships, new program placements all require senior operators with the bandwidth and judgment to execute. Senior operational hiring is slow, expensive, and constrained by labor market availability. The company’s growth rate is essentially capped by its hiring capacity at the senior layer.
In an agent-assisted operation, growth is gated by a different constraint. The company’s existing senior operators can absorb significantly more operational throughput because the routine documentation and review work has been compressed. The constraint shifts from senior labor capacity to the speed at which the company can extend its captured operational standards into new contexts and the speed at which the senior team can review and validate the expanded throughput.
This does not mean growth becomes unconstrained. It means the constraint moves to a layer that the company has more direct control over than the labor market. A company that can extend its prep standard to a new geography can extend its operations to that geography faster than a company that has to hire and train senior operators in the new location. A company that can apply its captured judgment to a new service line can launch that service line faster than a company that has to recruit operators with the requisite experience.
The companies that have begun operating in this mode are growing in ways that competitors cannot easily explain. The growth is not coming from a marketing breakthrough or a particularly successful acquisition. It is coming from a structural change in how senior operational capacity scales.
What this does to margin profile
What this does to margin profile.
The clearest economic effect of the shift, at the company level, is the change in the long-run margin profile.
A traditional restoration company has a margin structure dominated by labor cost in the production of operational work. Senior operator time is the largest input on most jobs and the least compressible cost line. Margin improvements at the company level are primarily achieved through volume increases, pricing power, or supply chain optimization. The margin ceiling is structurally constrained.
An agent-assisted restoration company has a margin structure where senior operator time has been redirected from routine production to higher-value work. The senior team is doing more strategic activity per hour worked. The routine work that used to consume their time is being done at a fractional cost. The margin per job improves not because the company is cutting corners but because the per-job cost of producing the operational substrate has dropped.
Over a twenty-four to thirty-six month period, the margin profile of an agent-assisted operation pulls visibly ahead of the margin profile of a traditional operation in the same market. The pull-ahead is gradual but durable. By the time it becomes obvious in the financials, the gap is large enough that catching up requires more than a single-year investment program.
The honest risk picture
The economic shift is not without risk. The companies operating well in this new mode are managing several specific risks that owners considering the transition need to understand.
The first risk is over-reliance on the AI capability. A company that lets the agent handle a function entirely without continued human oversight will eventually experience a quality failure that costs more than all the throughput gains combined. The senior operator review workflow is not optional. The economics work because the human is still in the loop. Companies that try to push the human out of the loop in pursuit of further cost savings learn the lesson the expensive way.
The second risk is the brittleness of the captured judgment. The agent is only as good as the standard it is operating against. As conditions change — new construction styles, new carrier dynamics, new regulatory environments — the standard has to evolve, and the evolution requires continued investment. Companies that build the agent capability and then stop investing in the underlying standard see the agent quality drift over time.
The third risk is vendor concentration. Companies that build their entire operational substrate against a single AI provider’s specific platform are exposed to vendor pricing changes, capability changes, and continuity risk. The companies operating well in this mode tend to keep their captured standards in vendor-neutral form, so that the underlying judgment can be moved to a different runtime if the original vendor relationship deteriorates.
The fourth risk is the team’s relationship with the technology. A senior operator who has been told the AI is going to make their job easier will be disappointed if it makes their job different rather than easier. The framing of the transition with the team has to be honest about what is changing and what is not. Companies that mishandle this framing experience attrition at the senior layer that can wipe out the operational gains entirely, as discussed in the source code piece.
What owners should be doing about this in 2026
If you run a restoration company and you have not yet begun the transition to agent-assisted operations, the practical implication of the economic shift is that the cost of starting now is significantly lower than the cost of starting in eighteen months and the value of starting now is significantly higher.
The cost is lower because the infrastructure is mature, the patterns are documented, and the early-adopter mistakes have been made by other people. A company starting in 2026 can move faster and avoid more pitfalls than a company that started in 2024.
The value is higher because the bid competitiveness, growth capacity, and margin implications of the shift are now beginning to manifest in real markets. A company that begins building the capability now will start producing measurable economic effect within twelve to eighteen months. A company that waits will be entering the work at the same time competitors are starting to convert the capability into market position.
The starting point is the documentation acceleration work described in the previous article. The economic implications described here flow from the operational substrate that documentation work creates. Without the substrate, none of the economics materialize. With the substrate, all of them do.
The owners who recognize this and act on it now will be running a different kind of business in 2028. The owners who do not will be looking at their numbers in 2028 and trying to figure out what changed in the market. What changed will not be the market. What changed will be the cost structure of the companies they are competing against.
Next in this cluster: how to evaluate AI tools without getting fooled — the practical buyer’s framework for cutting through vendor noise and making decisions that hold up over time.
By Will Tygart • Long-form Position • Practitioner-grade
The extraction protocol works. The pivot signal lexicon is learnable. The four-layer descent can be taught. The question is whether it can be deployed without a trained human interviewer in the room — and if so, how much of the value survives the translation.
This is the duplication problem at the center of the Human Distillery business model. Will can run an extraction session. An app cannot run the same session. But an app can run a version of the session — and for a large subset of extraction use cases, the version is sufficient.
Understanding what transfers and what doesn’t is the whole architectural question.
What Transfers to an App
The four-layer question structure is codifiable. A stateful conversational agent — not a chatbot, a system that maintains a running knowledge map of what’s been surfaced and what’s still needed — can execute the question sequences in order, navigate the domain-specific question libraries for a given vertical, and detect the linguistic markers of pivot signals in real time.
“It’s hard to explain” is detectable by NLP. Hedging patterns are detectable. Energy shifts in voice are detectable by acoustic analysis. Deflection to process — “the policy says…” — is detectable. The app can recognize these signals and adjust its question path, slowing down at tacit knowledge boundaries and applying the correct follow-up from the signal response library.
The processing pipeline from transcript to structured concentrate is fully automatable: chunking by topic boundary, entity extraction, claim isolation, confidence scoring, contradiction flagging across multiple sessions, multi-model distillation rounds. This is where AI earns its keep. A human doing this manually would take days per session. The pipeline does it in minutes.
Domain-specific question libraries can be built from prior extractions and expanded with each new session. The more sessions the app runs in a given vertical, the richer its question library becomes. This is the compounding effect that makes the app more valuable over time.
What Doesn’t Transfer
Three things resist automation in ways that won’t be resolved by better models:
Micro-hesitation reading. The half-second pause before an answer that signals the subject knows more than they’re about to say. The slight change in phrasing when someone moves from what they’re comfortable saying to what they actually think. These are real-time, embodied, relational signals. A text-based app misses them entirely. A voice app gets closer but still lacks the visual channel that carries a significant portion of this information.
Protocol abandonment. The decision to stop following the four-layer sequence because the subject just said something unprompted that is more important than anything in the protocol. Expert interviewers make this call constantly. They recognize the thread that, if followed, goes somewhere the protocol would never reach. An app will follow the signal response library. It won’t recognize when the library should be put down.
Trust calibration. Whether the subject is performing for the recording or actually sharing. This is not detectable from content analysis. It requires the social intelligence to know when to lower the formality, when to match the subject’s energy, when to say something self-deprecating to signal that this is a peer conversation and not an evaluation. Subjects share differently with someone they trust. The app cannot build that trust.
The Honest Architecture
The tiered model that emerges from this analysis:
Tier 1 — App-led extraction. Well-mapped domains with accessible knowledge. The subject is cooperative. The question library is deep. The knowledge being sought is in Layers 1 and 2. The app handles the session. Will reviews the concentrate before delivery.
Tier 2 — Human-led extraction with app processing. High-stakes sessions. Guarded subjects. Knowledge at the outer edge of verbalization (Layer 3 and 4). Will conducts the session. The app runs the processing pipeline. Will reviews and approves the concentrate.
Tier 3 — Full human extraction and distillation. Strategic engagements. Subjects who will only speak candidly to a person they know. Knowledge so embedded that it requires real-time relational judgment to surface at all. Will does everything.
The business model implication: Tier 1 is volume. Tier 3 is premium. The ratio shifts over time as the app’s question libraries deepen and its signal detection improves. What begins as mostly Tier 2 and 3 eventually becomes mostly Tier 1, with Will’s direct involvement reserved for the sessions where only a human can get the door open.
The app is not a replacement for the protocol. It’s a multiplier for the protocol — allowing it to run at a scale that a single human operator never could, while preserving the human layer for the cases that actually require it.
By Will Tygart • Long-form Position • Practitioner-grade
AI systems are good at identifying problems. Automated systems are good at fixing them. The failure mode that kills most AI automation projects is building them as one thing instead of two.
When you couple intelligence and execution in a single system, you get something that can do everything slowly and nothing reliably. The intelligence layer needs to be conversational, contextual, and judgment-driven. The execution layer needs to be deterministic, fast, and parallelizable. These are fundamentally different behaviors, and they require different tools.
The Work Order as the Bridge
The behavior-first design for AI automation has three distinct stages: identify (Claude analyzes a system and surfaces what needs to be done), deposit (Claude writes a structured work order to a persistent queue), and execute (a Cloud Run worker reads the work order and runs the fix).
The work order is the key artifact. It’s the contract between the intelligence layer and the execution layer. A well-formed work order contains everything the execution layer needs to run without asking Claude any follow-up questions: the target (site, post ID, endpoint), the operation (what to do), the parameters (how to do it), and the success criteria (how to know it worked).
When the work order is well-formed, the execution layer is a dumb runner. It doesn’t need to understand context, history, or judgment. It reads the work order, executes the operation, and writes the result back. The intelligence that produced the work order stays in the intelligence layer — which is exactly where it belongs.
What This Looks Like in Practice
In a multi-site content operation, Claude might analyze a WordPress site and identify 47 posts with missing FAQ schema. The tool-first approach runs Claude in a loop, generating and publishing schema for each post sequentially. This is slow, context-dependent, and fragile — if Claude loses context mid-run, the job is incomplete and the state is unclear.
The behavior-first approach: Claude generates 47 structured work orders, one per post, and deposits them in a Notion database with status “Queued.” A Cloud Run service reads the queue and processes each work order independently, in parallel, writing results back to each row. Claude is done in minutes. The Cloud Run service finishes the execution while Claude is doing something else entirely.
The behaviors are clean. The tools serve them. The system scales horizontally without requiring Claude to be in the loop for execution.
The Two Lanes of AI Automation
Not everything belongs in the work order queue. Some operations require judgment that the execution layer can’t replicate: content quality assessment, strategy decisions, anything where “it depends” is the correct first answer. These belong in a different lane — one where Claude stays in the loop through completion.
A mature AI automation architecture has both lanes clearly defined. Deterministic operations (taxonomy fixes, schema injection, meta rewrites, image uploads, internal link additions) go to the work order queue and run without Claude. Judgment-dependent operations (content strategy, quality review, client recommendations) stay in the conversational layer where Claude’s judgment can be applied continuously.
The discipline is in knowing which lane each operation belongs in — and resisting the temptation to put judgment-dependent work in the queue just because it would be faster. Faster execution of the wrong thing is not an improvement.
What does “surface the choice, not make it” mean? It is a design principle for human-AI collaboration: the AI’s role is to illuminate consequential moments — naming what is at stake and presenting the information needed to decide — while leaving the actual decision to the human. Neither silent execution nor reflexive refusal. Deliberate illumination.
There is a sentence I wrote today that I keep coming back to.
The goal is to surface the choice, not to make it.
I wrote it to describe a specific behavior — the way Claude will tell me when it thinks I should stop working, but doesn’t stop me. It names the moment. I decide. That’s it.
But the more I sit with it, the more I think it’s describing something much bigger than a late-night work session. It’s describing the only design philosophy that makes AI actually trustworthy.
Two Ways AI Can Fail You
There are two ways AI can fail you.
The first is an AI that makes choices silently. It executes, publishes, sends, optimizes. You find out later. This is the fully autonomous model — and it fails because you’re no longer in the loop. You’re downstream of the loop. Decisions were made for you, and you discover them after the fact. Even when the decisions are correct, this burns trust. Because you weren’t there.
The second failure mode is subtler and more common. It’s an AI that won’t engage with consequential moments at all. It hedges everything. It asks you to confirm every micro-step. It treats every action like a liability. You’re technically in the loop but the loop has become pure friction. Nothing gets done. This isn’t safety — it’s severance. The AI has cut itself off from being useful.
Both of these are design failures. And they share a common cause: the AI doesn’t know the difference between its domain and yours.
What Surfacing a Choice Actually Means
The sentence navigates between those two failure modes.
Surfacing a choice is different from making one and different from refusing one. It means bringing a consequential moment into view, naming what’s at stake, giving you the information you need — and then stopping. Leaving you exactly where you should be: at the lever.
I’ve been thinking about this as an illumination model. The AI doesn’t decide and it doesn’t refuse. It illuminates. It makes the decision visible so the human can make it intentionally instead of by accident or omission.
This sounds obvious until you watch how often it doesn’t happen.
Most AI products are optimized for either speed (make the choice, don’t interrupt the user) or safety theater (confirm everything, cover the liability). Neither one is actually designed around the question: whose domain is this decision in?
When it’s clearly the AI’s domain — formatting, fetching, drafting, calculating — execute silently. That’s what the user hired it for.
When it’s clearly the human’s domain — publishing live, committing under their name, spending money, overwriting data — surface it. One sentence, plain language, tappable confirm.
The hard part is the middle. Most of the interesting decisions live there.
The Confidence Gate — Same Principle at Scale
There’s a framework in agentic AI research called the confidence gate. The idea is that when an AI system’s confidence in a decision falls below a threshold, it routes the task to a human expert — not to redo the work, but to validate a specific choice point. The AI doesn’t fail closed. It doesn’t fail open. It surfaces the moment of uncertainty to the right person and then continues.
That’s the same principle at industrial scale.
The confidence gate isn’t just an engineering pattern. It’s a theory of trust. The more reliably a system surfaces choices instead of making them, the more trust accumulates. And the more trust accumulates, the more autonomy can be extended over time. Autonomy is earned by restraint.
An AI that makes choices silently — even correct ones — never builds that trust. Because you can’t verify what you can’t see.
What I’ve Noticed in Practice
The moments where Claude has earned the most trust in my operation are not the moments where it produced the best output. They’re the moments where it flagged something before I made a mistake I didn’t know I was about to make. The scope of a project I was underestimating. A piece of content that wasn’t ready. A decision that deserved fresh eyes.
It didn’t stop me. It named the moment.
And because it named the moment, I was actually deciding — not just executing on autopilot. That’s the loop going both ways. The AI surfaces the choice and the act of making the choice intentionally changes you. You slow down for a second. You look at the thing. You move the lever with your eyes open.
That pause is not overhead. That’s the whole point.
The Most Underrated Quality in AI
I think this is the most underrated quality in any AI system. Not capability. Not speed. The capacity to know when a moment belongs to the human and to hand it back cleanly.
Surface the choice, not make it.
Eleven words. Everything else is implementation.
— William Tygart
Frequently Asked Questions
What is the difference between an AI surfacing a choice and making one?
Surfacing a choice means the AI identifies a consequential decision point, presents the relevant information clearly, and stops — leaving the human to decide. Making a choice means the AI acts without presenting the decision to the human at all. The distinction is about who holds the lever at the moment that matters.
What is the confidence gate in agentic AI?
The confidence gate is an architectural pattern where an AI system routes a task to a human expert when its confidence in a decision falls below a defined threshold. Rather than proceeding blindly or stopping entirely, it surfaces the uncertain moment for human validation and then continues. It is a structural implementation of the surface-the-choice principle.
Why does silent AI execution erode trust even when the decisions are correct?
Trust requires visibility. When an AI makes decisions without surfacing them, the human has no way to verify that the right call was made — even if it was. Trust compounds through repeated verified moments, not through outcomes you discover after the fact. Correctness without transparency is not the same as trustworthiness.
How does surfacing choices relate to human-in-the-loop design?
Human-in-the-loop design keeps a person involved in an AI process, but the quality of that involvement varies widely. Surfacing choices is the positive form of human-in-the-loop: the AI actively identifies which moments require human judgment and presents them cleanly, rather than burying the human in confirmations or bypassing them entirely.
What does “autonomy is earned by restraint” mean in AI systems?
It means that the more reliably an AI surfaces choices instead of making them silently, the more trust the human operator builds in the system — and the more latitude they will grant it over time. An AI that demonstrates it knows the boundary of its own domain earns the right to operate more freely within that domain.
By Will Tygart • Long-form Position • Practitioner-grade
If you’re considering running Claude Managed Agents around the clock, you want a number. Not “it depends.” An actual number you can put in a budget. Here’s the math, worked out by scenario, with the honest caveats about where the real costs are.
The $0.08/session-hour charge only applies during active execution. Idle time — waiting for input, tool confirmations, external API responses — doesn’t count. This matters significantly for 24/7 workloads, because very few agents are active 100% of the time even when “running around the clock.”
The Maximum Theoretical Cost
Scenario: Agent running continuously, zero idle time, 24 hours a day, 30 days a month.
Token costs: separate, highly variable (see below)
$57.60/month is the ceiling on session runtime charges. You cannot pay more than this in session fees under any 24/7 scenario. But here’s the reality: that ceiling assumes zero idle time across the entire month, which doesn’t describe any real production agent.
Realistic 24/7 Scenarios
Realistic 24/7 scenarios.
Monitoring Agent (High Idle Ratio)
Runs continuously watching for triggers — error alerts, specific data patterns, incoming requests. Activates on trigger, processes, returns to monitoring state.
Assumption: 5% active execution time (watching 95% of the time, executing 5%)
Active hours: 24 × 30 × 0.05 = 36 hours/month
Session runtime: 36 × $0.08 = $2.88/month
Token costs: low — moderate bursts on trigger events
Realistic total: $5–15/month
Customer Support Agent (Business Hours Active)
“24/7” in the sense of always-available, but actual request volume concentrates in business hours. Waits for tickets, processes them, waits again.
Assumption: 8 hours/day active execution, 16 hours waiting
Active hours: 8 × 30 = 240 hours/month
Session runtime: 240 × $0.08 = $19.20/month
Token costs: depends heavily on ticket volume and average length
At 100 tickets/day with moderate length: likely $30–80/month in tokens
Realistic total: $50–100/month
Continuous Autonomous Pipeline
Batch processing agent that runs continuously through a queue with minimal waiting — the closest to true 24/7 active execution.
Assumption: 20 hours/day truly active (4 hours queue exhaustion/maintenance)
Active hours: 20 × 30 = 600 hours/month
Session runtime: 600 × $0.08 = $48/month
Token costs: high — continuous processing means continuous token consumption
This is where tokens become the dominant cost driver by a significant margin
For any 24/7 workload that’s genuinely busy, token costs will substantially exceed session runtime costs. The math:
A moderately active agent processing 10,000 input tokens and 2,000 output tokens per hour with Claude Sonnet 4.6 (legacy — still listed):
Input: 10,000 tokens × $3/million = $0.03/hour
Output: 2,000 tokens × $15/million = $0.03/hour
Token cost: $0.06/hour vs. session runtime of $0.08/hour — roughly equal at this volume
Scale to 100,000 input tokens and 20,000 output tokens per hour (a busy processing agent):
Input: $0.30/hour; Output: $0.30/hour
Token cost: $0.60/hour vs. session runtime of $0.08/hour — tokens are 7.5× the runtime charge
The session runtime fee is flat and bounded. Token costs scale with workload volume. For high-volume 24/7 agents, optimize token efficiency (prompt caching, context management, output brevity) before worrying about the session runtime charge.
Prompt Caching Changes the Token Math
If your agent has a large, stable system prompt — common in agents with extensive tool definitions or knowledge bases — prompt caching dramatically reduces input token costs. Cache hits cost a fraction of base input rates. For a 24/7 agent with a 20,000-token system prompt hitting the same context repeatedly, caching that prompt can cut input costs by 80–90%. The session runtime charge is unchanged, but the total cost picture improves significantly.
Now that you have the cost math — here’s how to choose and implement
You now know what Managed Agents costs at scale. The next decision is whether it’s the right architecture vs. OpenAI’s equivalent — and what the implementation actually looks like in practice.
