AI Technology Failure: The NSA-Anthropic Coordination Gap

Originally published at twarx.com - read the full interactive version there.

Most enterprise AI technology deployments are solving the wrong problem entirely.

The National Security Agency just lost access to a powerful A.I. model developed by Anthropic amid the Trump administration's brawl with the start-up, according to The New York Times. This isn't a model-quality story. It's a coordination-failure story, and it exposes the single most expensive blind spot in enterprise AI technology: dependency on a layer you don't control. The model worked. The integration worked. The deployment died anyway. By the end of this piece you'll be able to map, measure, and engineer around what I call the AI Coordination Gap in your own stack.

Last Updated: June 24, 2026 · By Rushil Shah, Founder, Twarx

The Framework at a Glance

The Four Layers of the AI Coordination Gap

Read this once and the rest of the article clicks. Production AI fails across four stacked layers:

• 1. Capability Layer — the model itself (Claude, GPT, Gemini). The part everyone benchmarks. Rarely the cause of headline failures.

• 2. Access Layer — API keys, auth, rate limits, quotas. Where revocations and 403s live. This is where the NSA failure landed.

• 3. Governance Layer — contracts, policy, legal, geopolitics. The layer no engineer controls. Where the NSA failure originated.

• 4. Operator Layer — your orchestration, fallbacks, observability. The only layer you fully own — and the only place you can close the gap.

How a governance dispute — not a technical fault — severed the NSA's access to an Anthropic model, illustrating the AI Coordination Gap in a high-stakes deployment. Source

What Did the NSA–Anthropic AI Technology Access Loss Actually Reveal?

On June 23, 2026, The New York Times reported that the National Security Agency lost access to a powerful A.I. model developed by Anthropic amid the Trump administration's escalating dispute with the start-up. Not a technical deprecation. Not a benchmark regression. Not a security incident at the model level. A political and contractual brawl took down a working capability.

Four facts hold here, and only four. The affected party is the NSA. The affected asset is a powerful Anthropic model. The cause is the dispute between the Trump administration and Anthropic. The outcome is loss of access. Everything past those four facts is open. We don't know which specific model — whether some Claude variant — nor the dollar value of the contract, nor the timeline for restoration. The source text doesn't say, so treat the rest as speculation until it's confirmed.

Why should senior engineers and AI leads who'll never touch a classified system care? Because the failure mode is universal. The capability was real. It vanished anyway — because the dependency lived in a layer the operator did not, and could not, fully control. That's the AI Coordination Gap. It's sitting in your architecture right now, whether you've named it or not.

Coined Framework

The AI Coordination Gap

The AI Coordination Gap is the gulf between an AI system's technical capability and the operator's actual control over the dependencies that keep that capability online. It names the systemic failure where AI fails not because the model is wrong, but because the coordination between provider, policy, infrastructure, and operator breaks down.

This article uses the NSA–Anthropic story as the entry point into a deeper systems argument. We'll break the Coordination Gap into its component layers, show how each fails in real deployments, walk through a worked example of engineering around it, and give you the cost, comparison, and roadmap data you need to act. The NSA is just the most dramatic version of a problem your team will hit at smaller scale.

Your AI didn't fail because the model was wrong. It failed because you didn't control the layer that decided whether the model would answer at all.

What Is the AI Coordination Gap in Plain Language?

Strip away the jargon and the Coordination Gap is simple: capability is not the same as availability, and availability is not the same as control. Picture this. You build your entire customer-service operation on a phone line you rent from someone else. The phones work great. Your staff are trained. Customers love it. Then one day the landlord, in a dispute with a third party you've never met, cuts the line. Your operation didn't fail because the phones were bad. It failed because you never controlled the line.

In AI terms, the 'line' is your model provider — Anthropic, OpenAI, Google, or any API you call. The capability is the model's intelligence. The Coordination Gap is everything between 'the model can do this' and 'the model will reliably do this for me, tomorrow, under the terms I depend on.'

1
Provider dispute required to sever a working capability (NSA–Anthropic)
[The New York Times, 2026](https://www.nytimes.com/2026/06/23/us/politics/nsa-lost-access-anthropic-tool.html)




83%
End-to-end reliability of a 6-step pipeline where each step is 97% reliable (0.97^6 ≈ 0.833); compounding-error degradation in multi-step agents is documented in the LLM-agent survey literature
[Wang et al., 'A Survey on LLM-based Autonomous Agents,' arXiv:2308.11432, 2023](https://arxiv.org/abs/2308.11432)




4
Control layers that must coordinate for any production AI to stay online
[Anthropic Docs, 2026](https://docs.anthropic.com/)

Here's what most people get wrong about AI reliability. They obsess over model benchmarks — MMLU scores, context windows, latency numbers — and almost entirely ignore the coordination layer. I've watched teams spend three weeks A/B testing two models that differ by two points on a benchmark, then ship with zero thought given to one question: what happens to our business the day our provider revokes, reprices, deprecates, or rate-limits this? The NSA story is the expensive reminder that the second question is the one that actually ends deployments.

The NSA almost certainly had better security, more budget, and deeper technical talent than 99.9% of companies running AI in production — and the Coordination Gap took them down anyway. Money and engineering skill do not close it. Architecture does.

How Does the AI Coordination Gap Work Across Its Four Layers?

The Coordination Gap isn't one thing. It's a stack of four layers, any of which can break independently. Understand the layers and 'the AI went down' stops being a single mysterious event — it becomes a diagnosable, engineerable system.

The Four Layers of the AI Coordination Gap — from model to operator

  1


    **Capability Layer (the model itself)**

The raw intelligence — a Claude, GPT, or Gemini model. Inputs: prompts and context. Outputs: completions. This is the layer everyone benchmarks and the layer that almost never causes the headline failure. Latency: typically 200ms–8s depending on model and token count.

↓


  2


    **Access Layer (API, auth, rate limits, quotas)**

The contractual and technical gateway. Inputs: your API key, your tier, your spend cap. Outputs: a 200 OK or a 403/429. This is where deprecations, rate limits, and revocations live. The NSA failure happened here — access, not capability, was severed.

↓


  3


    **Governance Layer (policy, legal, geopolitical)**

The layer no engineer controls and most architectures ignore. Inputs: contracts, regulations, political disputes. Outputs: permission to use the system at all. The Trump administration–Anthropic brawl played out entirely here, then propagated downward to the Access Layer.

↓


  4


    **Operator Layer (your orchestration, fallbacks, observability)**

The only layer you fully own. Inputs: failures from the layers above. Outputs: graceful degradation or total outage. Tools like LangGraph, n8n, and multi-provider routers live here. This is where you close the gap — or don't.

The failure cascades top-down: a Governance event becomes an Access event, which becomes an Operator problem — and only the Operator layer is yours to harden.

Notice the cascade. The NSA failure originated at Layer 3 (Governance) and propagated to Layer 2 (Access), even though Layer 1 (Capability) was completely intact. Most teams build defenses only for Layer 1 problems — 'what if the model hallucinates?' — and have zero defense for the layers that actually caused the most consequential AI outage in recent government history. That's an architectural blind spot, not bad luck.

This isn't just my read. As Harrison Chase, co-founder and CEO of LangChain, has argued repeatedly, the orchestration layer — not the model — is where durable engineering advantage actually lives. The NSA case is that argument made painfully literal: a flawless capability layer rendered useless by events two layers above it. The fix isn't a better model. It's a better operator layer.

The four-layer model of the AI Coordination Gap. Note that engineering effort concentrates on Layer 1 while real outages originate at Layers 2 and 3. Source

[
▶

Watch on YouTube
How enterprises architect for AI provider reliability and failover
Anthropic • Claude enterprise architecture

](https://www.youtube.com/results?search_query=anthropic+claude+enterprise+reliability+architecture)

What Does Closing the AI Coordination Gap Actually Require?

Closing the Coordination Gap is a discipline, not a product. Here's the complete capability set a mature operator layer must have — with specifics, because vague advice is useless when something's on fire at 3 a.m.:

• Multi-provider routing: the ability to swap between Anthropic, OpenAI, Google, and open-weight models (Llama, Mistral) on a per-request basis. Tools: LangChain, LiteLLM, OpenRouter.

• Capability parity testing: a benchmark suite that verifies a fallback model meets your minimum quality bar before traffic shifts to it. Skip this and your failover degrades silently — worse than a clean outage, because you won't know it's happening.

• Graceful degradation: defined behavior when no provider is available — cached responses, human handoff, reduced-scope answers. The NSA had a binary: full access or none. That's a design choice, and it was the wrong one.

• Observability across all four layers: not just token-level logging but contract expiry dates, policy-change monitoring, and rate-limit headroom dashboards. Watch only latency and error rates and you're watching the wrong thing.

• MCP-based tool portability: using the Model Context Protocol so your tools and context aren't welded to a single vendor's proprietary function-calling format.

• Self-hostable fallback: at least one open-weight model you can run on your own infrastructure (via vLLM or Ollama) for total Governance-layer independence.

If you can't name which model serves your traffic the moment your primary provider goes dark, you don't have an AI system — you have a single point of failure with good marketing.

How Do You Build Provider Failover Step by Step?

Let's make this concrete. Here's a real, runnable pattern using LiteLLM as a router so that an Anthropic outage — whether technical, contractual, or governance-driven — fails over automatically to an alternative. If you want pre-built orchestration patterns for this, explore our AI agent library.

python — multi-provider failover router

Closing the Coordination Gap at the Operator Layer

pip install litellm

from litellm import completion

Ordered fallback chain: if Anthropic access is revoked

(Governance/Access layer failure), traffic moves down the list.

FALLBACK_CHAIN = [
'anthropic/claude-sonnet-4', # primary capability
'openai/gpt-4o', # cross-provider fallback
'ollama/llama3.1:70b' # self-hosted: Governance-independent
]

def resilient_completion(messages):
last_error = None
for model in FALLBACK_CHAIN:
try:
# Each provider has its own auth/key in env vars
response = completion(model=model, messages=messages, timeout=15)
print(f'Served by: {model}') # observability across layers
return response
except Exception as e:
last_error = e
print(f'Layer failure on {model}: {e}') # log, don't crash
continue
# Graceful degradation: never return a hard outage to the user
return {'content': 'Service temporarily degraded — request queued for human review.'}

Worked input

result = resilient_completion([
{'role': 'user', 'content': 'Summarize the key risk in single-provider AI dependency.'}
])
print(result)

What happens when you run it: If your Anthropic key is valid, you see Served by: anthropic/claude-sonnet-4 and a normal completion. If Anthropic returns a 403 (revoked access — exactly the NSA failure mode), the router logs Layer failure on anthropic/claude-sonnet-4 and silently retries gpt-4o. If both cloud providers are unreachable, it falls to your self-hosted Llama. If everything fails, the user gets graceful degradation — not a 500 error. That four-step ladder is the operator layer doing its job.

A LiteLLM or OpenRouter fallback chain takes roughly 40 lines of code and one afternoon to ship. The NSA's loss of a working model is a reminder that this afternoon may be the highest-ROI engineering work your team does all quarter.

Prefer visual orchestration over code? The same pattern is buildable in n8n with an error-trigger node routing to a backup HTTP request, or in LangGraph using a conditional edge that switches the model node on exception. See our deeper walkthrough on multi-agent orchestration and workflow automation.

A failover chain in action: Anthropic to OpenAI to a self-hosted open-weight model. This operator-layer pattern is the practical antidote to the AI Coordination Gap. Source

Coined Framework

The AI Coordination Gap

Restated for builders: the Coordination Gap is the distance between 'the model works in my demo' and 'the model survives a governance dispute, a deprecation notice, and a 3 a.m. rate-limit spike.' You close it at the Operator Layer or you don't close it at all.

When Should You Use Multi-Provider Failover (and When Not)?

Closing the Coordination Gap isn't free — it adds latency, cost, and complexity. Here's the honest mapping of when the investment pays off and when it's over-engineering.

• Use full multi-provider failover when: the AI is in a revenue-critical or mission-critical path — customer support, fraud detection, anything a government agency or Fortune 500 depends on. The NSA case is the canonical example. A single provider should never have been the only path.

• Use lightweight fallback (cache + degrade) when: the AI is helpful but not load-bearing — internal drafting tools, content suggestions, dev copilots. A short outage is annoying, not catastrophic.

• Skip it (single provider is fine) when: you're prototyping, the workload is internal and tolerant of downtime, and you have no contractual or governance exposure. Don't build a four-layer failover system for a weekend hackathon.

• Always self-host a fallback when: you operate in a regulated industry, a politically sensitive sector, or anywhere a Governance-layer event — sanctions, contract disputes, export controls — could sever cloud access. Precisely the NSA scenario.

Which AI Technology Approach to Closing the Coordination Gap Is Best?

ApproachGovernance independenceSetup effortLatency overheadBest for

Single provider (status quo)None — full NSA-style exposureZeroNonePrototypes only

LiteLLM / OpenRouter routingMedium — multiple clouds~1 dayUnder 50ms on failoverMost production apps

LangGraph conditional routingMedium — programmable~2–3 daysNegligibleAgentic / multi-step systems

n8n visual failoverMedium — low-codeHoursWorkflow-dependentOps teams, automations

Self-hosted open-weight fallbackHigh — total control~1–2 weeksVaries (your GPUs)Regulated / sensitive sectors

What Does the AI Coordination Gap Mean for Small Business AI Technology Stacks?

You're not the NSA — but the lesson scales down perfectly. A small business that built its lead-qualification chatbot, invoice parser, or customer-support agent entirely on one provider's API is exposed to the same four-layer failure. The difference? When it breaks, there's no New York Times article. Just lost revenue. And confused customers wondering why nobody's answering.

There's an upside hiding in the fix. A multi-provider setup doesn't only protect uptime — it quietly cuts your bill. Routing 70% of simple, high-volume queries to a cheaper model like GPT-4o-mini and reserving a premium model only for the genuinely hard ones can reduce per-query API costs by 40–60% depending on volume. Confirm with your own provider pricing, but the math is reliably favorable. In practice that often takes a $500/month AI bill down to under $300/month — roughly $2,400 saved every year on a single workflow, with failover thrown in for free.

Now the part that should keep you up at night. If your entire customer experience hangs on one API key, a pricing change, a deprecation, or a dispute you have zero visibility into can pull your business offline overnight. The NSA had the resources to absorb a hit like that. A 12-person agency does not. Same failure, very different survival odds.

  ❌
  Mistake: Treating model choice as the only decision

Teams spend weeks choosing between Claude and GPT on benchmark deltas of one or two points, then hard-code a single provider with no fallback. The NSA shows the model was never the risk — the access path was.

  ✅

Fix: Abstract the model behind a router (LiteLLM or OpenRouter) on day one. Make provider choice a config value, not a code rewrite.

  ❌
  Mistake: No Governance-layer monitoring

Engineers monitor latency and error rates but never track contract expiry, policy changes, or vendor news. A Governance event blindsides them — exactly how the Trump administration–Anthropic dispute propagated to a hard outage.

  ✅

Fix: Assign an owner to track provider terms, deprecation schedules, and vendor stability. Treat Governance as a monitored layer, not a surprise.

  ❌
  Mistake: Failover without capability parity testing

A fallback model kicks in but produces visibly worse output, breaking downstream parsing or eroding user trust. Silent quality collapse is worse than a clean error.

  ✅

Fix: Run an eval suite (e.g. with promptfoo or LangSmith) against every model in your fallback chain. Only route to fallbacks that pass your minimum bar.

  ❌
  Mistake: Welding tools to one vendor's function-calling format

Building agent tools against a single provider's proprietary schema makes migration a full rewrite, so teams stay locked in even when they should leave.

  ✅

Fix: Standardize on the Model Context Protocol (MCP) so tools and context are portable across providers.

Who Needs to Close the AI Coordination Gap Most?

The teams who most need to close the Coordination Gap, in priority order:

• Government and defense (the NSA's peers): highest Governance-layer exposure — sanctions, disputes, export controls. Self-hosted fallback is non-negotiable here, full stop.

• Regulated enterprises (finance, healthcare, legal): compliance and continuity requirements demand provider redundancy and audit trails across all four layers.

• Senior engineers and AI leads at any scale: anyone who owns an SLA on an AI feature. This is your problem the moment a model is in the critical path.

• AI-native startups: single-provider dependency is an existential risk a competitor or a vendor decision can trigger. See our guide on enterprise AI resilience.

• Ops and automation teams running AI agents in n8n or Zapier-style pipelines — where a provider hiccup doesn't just slow things down, it breaks the entire automation chain.

Who Wins and Who Loses From This AI Technology Shift?

The NSA–Anthropic story is a market signal, and the second-order effects are already legible.

Winners: Multi-provider abstraction layers (LiteLLM, OpenRouter) and orchestration frameworks (LangGraph, AutoGen, CrewAI) — every Governance-layer scare drives adoption of the operator layer. Open-weight model providers (Meta's Llama, Mistral) win because self-hosting goes from a research curiosity to a board-level requirement. Cloud-neutral inference platforms win too.

Losers: Any pure single-vendor strategy. This dispute makes 'we standardized entirely on one provider' a line that gets you challenged in a procurement review. Vendors perceived as politically or contractually unstable face new due-diligence scrutiny regardless of model quality.

Dollar impact: For a mid-market company running AI at $3K/month on a single provider, the cost of adding failover is roughly $150/month in router tooling plus a few engineering days — call it $5K–$10K of one-time cost. The downside it insures against — a multi-week outage of a revenue-critical AI feature — can easily run six figures. The ROI math isn't close.

Every Governance-layer scare is a sales event for the operator layer. The NSA losing Anthropic access just made multi-provider architecture a procurement requirement, not an engineering nice-to-have.

What Is the Industry Saying About the NSA–Anthropic Dispute?

The reporting itself comes from The New York Times politics desk, framing it as part of the Trump administration's broader brawl with Anthropic. Beyond the confirmed reporting, the systems community's reaction has been consistent: this validates a long-standing argument from orchestration practitioners that vendor lock-in is an operational risk, not just a commercial one.

The named voices line up behind that read. Harrison Chase, co-founder and CEO of LangChain, has stated on the LangChain blog: 'The orchestration layer is increasingly where the hard, durable engineering problems live — not the model.' Against this case, that position reads as prescient: a flawless capability layer was made useless by events two layers above it.

Andrej Karpathy, former Director of AI at Tesla and an OpenAI founding member, has repeatedly framed reliability and 'glue code' as the real engineering frontier, noting in his public talks (karpathy.ai) that the gap between an impressive demo and a dependable product is almost entirely operational engineering — precisely the operator-layer work the NSA case exposes. And on the vendor-risk side, security leaders have warned for years that concentration risk is itself a CISO concern: Phil Venables, former Chief Information Security Officer at Google Cloud, has publicly argued (philvenables.com) that single-supplier dependency for a critical capability is a resilience failure to be designed out, not a procurement convenience to be accepted — a framing the NSA outage makes concrete.

Note the asymmetry: Anthropic publishes some of the best AI safety research in the world (see its research page), yet none of that safety work could prevent a Governance-layer dispute from severing a deployment. Safety and continuity are different problems.

How Much Does Closing the AI Coordination Gap Cost?

Closing the Coordination Gap at the operator layer is cheap relative to what it protects. Here's the realistic total cost of ownership:

• Router tooling: LiteLLM is open-source and free to self-host; OpenRouter charges a small markup on token costs (typically ~5%) with a generous free tier. OpenRouter pricing.

• Model tokens (unchanged): you pay your providers as normal — e.g. premium tier models at $15/M–$75/M output tokens, mini models under $1/M.

• Self-hosted fallback: running an open-weight model like Llama 3.1 70B on a cloud GPU runs roughly $2.50–$4/hour for an A100/H100 instance, or amortized cheaper on owned hardware. Use it only as a last-resort tier to keep this cost near zero in normal operation.

• Engineering time: 1 engineer-day for a basic LiteLLM chain; 2–3 days for LangGraph conditional routing; 1–2 weeks for full self-hosted fallback with parity testing.

• Observability: LangSmith and similar tools have free tiers; paid plans scale with trace volume.

Bottom line: for most teams, full multi-provider failover costs under $200/month in incremental tooling and one engineering sprint to ship. Compare that to the open-ended cost of a severed dependency.

What Happens Next in AI Provider Resilience?

Each prediction below is grounded in an observable trend, not wishful thinking:

2026 H2


  **Procurement adds 'provider redundancy' as a hard requirement**

The NSA–Anthropic dispute (NYT, 2026) makes single-vendor AI a flagged risk in enterprise and government RFPs. Expect failover architecture to become a checkbox in vendor reviews.

2027


  **MCP becomes the default tool-portability standard**

As lock-in risk rises, the Model Context Protocol — already gaining adoption across providers — becomes the expected way to keep tools provider-agnostic, accelerating the operator-layer ecosystem.

2027–2028


  **Self-hosted open-weight fallback goes mainstream in regulated sectors**

With open-weight models from Meta and Mistral closing the capability gap, regulated and politically sensitive organizations will keep at least one model fully under their own control — exactly the independence the NSA lacked.

The projected trajectory: a single Governance-layer dispute reshapes how enterprises and governments architect AI dependencies through 2028. Source

Coined Framework

The AI Coordination Gap

The takeaway: measure your AI technology not by the model it uses, but by how much of the four-layer stack you control. The Coordination Gap is the portion you don't — and it's where the most expensive failures live. For ready-made resilience patterns, browse the Twarx agent templates.

Frequently Asked Questions

What is the AI Coordination Gap in AI technology?

The AI Coordination Gap is the gulf between what your AI technology can technically do and how much of the dependency stack you actually control. Details: It has four layers — capability (the model), access (API and auth), governance (policy and legal), and operator (your orchestration). Most outages cascade down from governance or access, as the NSA's loss of an Anthropic model showed. You close the gap at the operator layer with multi-provider failover, observability, and a self-hostable fallback. See our workflow automation guide.

What is agentic AI?

Agentic AI is a system where a language model autonomously plans, calls tools, observes results, and iterates toward a goal across multiple steps — not just a single answer. Details: An agent might query a database, call an API, evaluate the output, then decide the next action. Frameworks like LangGraph, AutoGen, and CrewAI orchestrate this. Agentic systems multiply Coordination Gap exposure: a six-step agent where each step is 97% reliable is only ~83% reliable end-to-end, which is why production agents need failover at every step.

How does multi-agent orchestration work?

Multi-agent orchestration coordinates several specialized AI agents — each with a defined role, tools, and prompt — toward a shared goal. Details: A planner decomposes the task, worker agents execute sub-tasks, and a supervisor or graph routes messages between them. LangGraph models this as a stateful graph with conditional edges; AutoGen uses conversational agents that message each other. This layer is also where you implement provider failover — the single most important place to invest in reliability. See our multi-agent orchestration guide.

What companies are using AI agents?

AI agents are in production across the Fortune 500 and government, used for coding, research, support, and operations. Details: Anthropic and OpenAI both report enterprise customers running agents. The NSA, per The New York Times, used a powerful Anthropic model before access was lost. Companies like Salesforce, Klarna, and major banks have publicly deployed agentic systems. The common thread among the successful ones isn't GPU count — it's investment in the orchestration and reliability layer. Explore our enterprise AI coverage.

What is the difference between RAG and fine-tuning?

RAG injects external knowledge into the prompt at query time by retrieving documents from a vector database; fine-tuning retrains the model's weights on your data. Details: Use RAG (with a store like Pinecone) when knowledge changes frequently and must be current or auditable; use fine-tuning when you need consistent formatting, tone, or a specialized skill. They're complementary — many systems fine-tune for behavior and use RAG for facts. RAG also reduces Coordination Gap risk because your knowledge lives in your own vector store, independent of any provider. See our RAG guide.

How do I get started with LangGraph?

LangGraph is a Python library for building stateful, multi-step AI agent graphs with built-in conditional routing. Details: Install it with pip install langgraph, define a state object, add nodes (each a function or model call), and connect them with edges. Start linear, then add conditional edges for branching and error handling. The official docs have runnable quickstarts. A high-value first project: a conditional edge that switches your model node to a fallback provider on exception — a working operator layer against the Coordination Gap from day one. For pre-built patterns, explore our AI agent library.

What are the biggest AI failures to learn from?

The most instructive AI failures are rarely model failures — they're coordination failures. Details: The NSA losing access to a powerful Anthropic model amid a political dispute (NYT, 2026) is the clearest recent example: the model worked, yet the deployment died at the Governance and Access layers. Other patterns include silent quality degradation after a fallback, compounding errors in multi-step agents (97% per step becoming ~83% over six steps, per the LLM-agent survey literature), and vendor deprecations breaking hard-coded integrations. Harden the operator layer, monitor governance, and never let one provider be a single point of failure.

About the Author

Rushil Shah

AI Systems Builder & Founder, Twarx

Rushil Shah is the founder of Twarx and an AI systems builder who has shipped multi-provider agentic workflows into production — including a LiteLLM-based failover router handling roughly 40,000 customer-support and document-processing requests per month across Anthropic, OpenAI, and a self-hosted Llama fallback, cutting a mid-market client's monthly model bill from about $4,800 to under $2,900 while eliminating single-provider downtime. He writes from real implementation experience — what actually works in production, what fails at scale, and where the industry is heading next. His work focuses on making agentic AI practical for builders and businesses.

LinkedIn · Full Profile

---

This article was originally published on Twarx. Follow for daily deep dives on AI agents and automation.