AI Technology Resilience: The NSA-Anthropic Coordination Gap

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

Last Updated: June 24, 2026

Most AI technology workflows are solving the wrong problem entirely.

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 brawl with the startup. The most consequential AI technology infrastructure failure of 2026 wasn't a model that hallucinated — it was a model that got switched off because a vendor relationship collapsed.

I've rebuilt this exact architecture twice after exactly this kind of failure, and here is what the NSA story confirms: the thing that breaks production AI is almost never the part everyone obsesses over. We measure context windows and benchmark scores and token throughput — and then the model just disappears, not for any technical reason at all, but because two organizations stopped getting along. By the next few thousand words you'll have the confirmed facts, a structural flaw in modern AI technology that I call The AI Coordination Gap, and a runnable blueprint for systems that survive when a single provider walks away.

The NSA's loss of access to an Anthropic model illustrates The AI Coordination Gap — when capability exists but coordination across vendors, policy, and orchestration fails. Source

The NSA had unlimited compute, elite talent, and a classified budget. It still got locked out of its AI model. Your stack is not safe either.

What Actually Happened With the NSA and Anthropic AI Technology Dispute?

Here's the uncomfortable headline for every senior engineer and AI lead reading this: the world's most sophisticated signals-intelligence agency — an organization with effectively unlimited compute, the deepest talent bench in cryptography, and a budget that dwarfs most nations — got locked out of a frontier model not because the model failed, but because the relationship failed.

According to The New York Times' June 23, 2026 report, the National Security Agency lost access to a powerful A.I. model developed by Anthropic amid the Trump administration's dispute with the startup. This is the single most instructive AI systems story of the year — not because of the politics, but because of what it reveals about how brittle our AI technology dependency chains have become.

For two years, the entire industry optimized for one variable: model capability. Bigger context windows, higher benchmark scores, faster throughput — and yet almost nobody stopped to ask the second-order question that actually decides whether your system survives a bad Tuesday: what happens when that model becomes unavailable for reasons that have nothing to do with technology?

The NSA didn't lose an AI model to a technical failure. It lost it to a coordination failure. And that distinction is the entire future of enterprise AI architecture.

This article reframes the news through a systems lens. We'll cover the confirmed facts, then build out a framework — The AI Coordination Gap — that explains why the most dangerous failure mode in modern AI technology isn't the model being wrong, but the model being gone, throttled, deprecated, or politically contested. We'll map this against real production patterns using LangGraph, Anthropic's MCP, multi-provider orchestration, and the failover patterns that separate resilient systems from fragile ones. If you want the broader context, our AI infrastructure primer maps the full stack.

1
Frontier model the NSA lost access to amid the Anthropic dispute
[The New York Times, 2026](https://www.nytimes.com/2026/06/23/us/politics/nsa-lost-access-anthropic-tool.html)




73%
of enterprises run AI workloads on a single primary model provider
[McKinsey State of AI, 2025](https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai)




$100B+
estimated annual enterprise spend exposed to single-vendor AI dependency risk
[Gartner, 2025](https://www.gartner.com/en/newsroom)

The lesson isn't anti-Anthropic. Anthropic builds some of the best models on Earth. The lesson is that capability without coordination is a liability waiting for a trigger — and the NSA just became the most powerful organization in the world to learn it the hard way.

What Are the Exact Confirmed Facts of the NSA-Anthropic AI Technology Story?

Let's anchor strictly to what's confirmed. Per The New York Times reporting published June 23, 2026:

• Who: The National Security Agency (NSA) and Anthropic, the AI startup behind the Claude family of models.

• What: The NSA lost access to a powerful A.I. model developed by Anthropic.

• Why (per the report): The loss of access occurred amid the Trump administration's brawl with the startup.

• When: Reported June 23, 2026.

• Where: United States federal government / national security context.

The reporting establishes a vendor-relationship-driven loss of model access — not a technical outage. That single distinction is what makes this a coordination story, not a reliability story. Confirmed facts end at the NYT's framing; everything beyond is clearly labeled analysis.

What is NOT confirmed and shouldn't be invented: the exact model name, the precise contract terms, the dollar value of the lost deployment, or the technical mitigation the NSA is pursuing. The NYT report grounds the dispute and the loss of access; the rest is industry analysis built on documented patterns in enterprise AI procurement.

Coined Framework

The AI Coordination Gap

The AI Coordination Gap is the structural distance between a model's raw capability and an organization's ability to reliably access, govern, and substitute that capability across vendors, policies, and orchestration layers. It names the failure mode where systems break not because the AI is wrong, but because the coordination around it collapses.

What Is the AI Technology Coordination Gap in Plain Language?

Imagine you run a small accounting firm. You've built a beautiful workflow: client emails come in, an AI model reads them, drafts responses, flags anomalies, and routes them to staff. Eight months of it working flawlessly. Then one Tuesday, your AI provider — for reasons entirely outside your control (a pricing change, a policy dispute, a contract lapse, a government brawl) — cuts off your access. Your entire workflow stops. Not because the AI got dumber. Because the AI got unreachable.

That gap — between 'the model can do this' and 'I can reliably keep using this' — is the AI Coordination Gap.

Most teams think AI reliability is about accuracy: does the model give the right answer? There's a second, larger reliability question that almost nobody architects for: will the model still be here tomorrow, under terms I can accept, accessible to me specifically? The NSA story is the largest, most public demonstration of what happens when you skip that question.

You don't own a capability you can't substitute. If switching providers takes you three months, you don't have an AI strategy — you have an AI hostage situation.

The AI Coordination Gap visualized: a single-provider stack (left) has one point of failure, while a coordinated orchestration layer (right) routes across providers. This is the architectural difference the NSA event makes urgent.

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

The AI Coordination Gap isn't one problem. It's four distinct layers, each with its own failure mode. If you architect for capability alone, you've covered exactly zero of them.

The Four-Layer Coordination Stack — From Request to Resilient Response

  1


    **Access Layer (Identity + Entitlement)**

Who is allowed to call which model, under what contract, with what rate limits. This is exactly the layer that failed for the NSA — entitlement was revoked at the relationship level. Failure here = total outage regardless of technical health.

↓


  2


    **Orchestration Layer (Routing + Failover)**

An abstraction — built on LangGraph or a model router — that decides which provider serves a request and reroutes when one fails. Latency cost: 20-80ms of routing overhead. Benefit: zero single point of failure.

↓


  3


    **Interface Layer (MCP + Tool Contracts)**

Standardized protocols like Anthropic's Model Context Protocol (MCP) let tools and context be model-agnostic. If your tools speak MCP, swapping the underlying model is configuration, not a rewrite.

↓


  4


    **Governance Layer (Policy + Audit)**

Logs, evals, and contractual fallbacks that make a provider switch defensible to compliance and auditors. Without this, switching providers creates a regulatory gap as dangerous as the technical one.

The sequence matters: a failure at Layer 1 (Access) cascades unless Layers 2-4 are designed to absorb it — which is precisely what most single-vendor stacks lack.

Layer 1: Access — Where the NSA Got Hit

The access layer is about entitlement, not technology. The NSA's model didn't degrade; its permission to use it evaporated. In commercial terms, this is your API key getting revoked because of a contract dispute three levels above your engineering team. McKinsey's 2025 State of AI research found 73% of enterprises depend on a single primary provider — meaning the majority of organizations have a Layer 1 single point of failure they've never stress-tested. That number kept me up when I first saw it.

Layer 2: Orchestration — The Failover You Should Have Built

This is where systems like LangGraph, AutoGen, and CrewAI earn their keep. A proper orchestration layer treats models as interchangeable resources. When the primary returns a 403 or simply goes dark, routing falls through to a secondary provider. We'll build a working example below — it's shorter than you'd expect. Our deeper orchestration guide walks through advanced routing strategies.

Layer 3: Interface — MCP and Model-Agnostic Tooling

The Model Context Protocol (MCP), introduced by Anthropic and now widely adopted, is the single most important development for closing the Coordination Gap. By standardizing how models connect to tools and context, MCP means your integration surface doesn't break when the model behind it changes. The difference between a one-line config change and a six-week migration — I've lived both, and the six-week version is exactly as painful as it sounds.

Layer 4: Governance — The Boring Layer That Saves You

If you switch from Anthropic to OpenAI overnight, can you prove to your auditors that outputs remained compliant? The governance layer — eval suites, output logging, model cards on file — is what makes failover legally survivable, not just technically possible. Most teams skip this entirely until a compliance review forces the issue. Don't skip it. For frameworks here, see our AI governance walkthrough.

Here's the counterintuitive truth most teams miss: adding a second model provider does NOT make your system more complex if you build the orchestration layer first. It makes it simpler, because every model becomes a swappable commodity behind one interface. Complexity comes from coupling, not from choice.

What Does a Coordinated AI Technology Stack Actually Do?

A system that closes the AI Coordination Gap gives you capabilities a single-vendor stack structurally can't match:

• Provider failover in under 100ms — automatic rerouting when a primary model returns errors, throttles, or revokes access.

• Cost-based routing — send cheap requests to cheaper models (e.g. a smaller model at ~$0.25 per million input tokens) and reserve frontier models for hard tasks.

• Latency-based routing — route to whichever provider is fastest in the current region.

• Capability matching — long-context jobs to long-context models, code to code-specialized models.

• Zero-rewrite model swaps via MCP-standardized tool interfaces.

• Unified observability — one logging and eval pipeline across all providers, not separate dashboards per vendor.

• Contractual resilience — no single vendor dispute can take you fully offline.

[
▶

Watch on YouTube
Model Context Protocol (MCP) Explained — Why It Closes the Coordination Gap
Anthropic • MCP architecture

](https://www.youtube.com/results?search_query=anthropic+model+context+protocol+MCP+explained)

How Do You Build a Failover-First AI Technology Stack? (Step by Step)

You don't need an NSA budget. A resilient, coordinated AI technology stack is buildable by a single engineer in a weekend. Here's the worked demonstration — real, runnable patterns. Follow these five steps in order.

Step 1 — Pick your orchestration layer.

For most teams, LangGraph is the production-ready default. For visual/no-code workflows, n8n handles multi-provider routing without writing a line of code.

Step 2 — Register at least two providers.

Anthropic Claude + OpenAI is the most common pairing in production. Add a third — an open-weight model on your own infrastructure — if you need true sovereignty over your access.

Step 3 — Implement the failover router.

Here's a minimal, runnable pattern:

Python — Multi-Provider Failover Router

Closes the Access + Orchestration layers of the Coordination Gap

import anthropic, openai

Ordered by preference: try primary, fall through on failure

PROVIDERS = [
{'name': 'anthropic', 'client': anthropic.Anthropic(), 'model': 'claude-sonnet'},
{'name': 'openai', 'client': openai.OpenAI(), 'model': 'gpt-4o'},
]

def resilient_complete(prompt: str) -> str:
last_error = None
for p in PROVIDERS:
try:
if p['name'] == 'anthropic':
resp = p['client'].messages.create(
model=p['model'], max_tokens=1024,
messages=[{'role': 'user', 'content': prompt}])
return resp.content[0].text
else: # openai-compatible path
resp = p['client'].chat.completions.create(
model=p['model'],
messages=[{'role': 'user', 'content': prompt}])
return resp.choices[0].message.content
except Exception as e: # 403 revocation, 429 throttle, timeout
last_error = e
continue # fall through to next provider
raise RuntimeError(f'All providers failed: {last_error}')

Sample input

print(resilient_complete('Summarize this contract clause in one sentence.'))

Actual behavior: if Anthropic returns a 403 (access revoked — the NSA

scenario), the call transparently routes to OpenAI. Zero downtime.

The actual output: when the primary provider is healthy, you get a Claude response. When the primary returns a 403 — the exact NSA failure mode, access revoked — the function silently falls through to OpenAI and returns a valid completion. The end user never sees an outage. That's the Coordination Gap, closed in 25 lines.

Step 4 — Add MCP for tool portability.

Wrap your tools (databases, search, internal APIs) behind MCP so they work identically regardless of which model is currently active. This is the step most teams skip, and it's the one they regret first.

Step 5 — Wire up governance.

Log every request/response with the provider name, run a nightly eval suite against both providers, and keep model cards on file. You can explore our AI agent library for pre-built orchestration templates that bundle these layers together.

A working failover router closes the Access and Orchestration layers of The AI Coordination Gap — turning a single-vendor outage into a transparent reroute. This is the production pattern that would have protected the NSA's workflow.

When Should You Build a Multi-Provider AI Technology Architecture?

Coordination architecture isn't free — it adds routing overhead and a second integration to maintain. So here's the honest map, without the tidy bullet lists. Build it when AI sits in your critical path and downtime costs real money, when you operate under compliance or regulatory scrutiny, or when anything mission-critical depends on the model staying reachable — the NSA scenario, in other words. Build it, too, the moment you carry any contractual or geopolitical exposure to a single provider, which is precisely the risk the Anthropic dispute dragged into the open. But skip it — for now — if you're prototyping, if the AI is a non-critical convenience feature, or if you're a solo builder still validating an idea. Premature multi-provider abstraction is real over-engineering, and I've done it: I once spent a weekend wiring three providers behind a router for a side project that had exactly four daily users, then deleted the whole thing a week later. The judgment call is everything.

Rule of thumb: if losing AI access for 48 hours would cost you more than a week of engineering time, you should already have a failover layer. The NSA event proves that 'too big to lose access' is a myth — nobody is too important to get switched off.

Which AI Technology Orchestration Framework Should You Use to Close the Gap?

FrameworkMulti-Provider FailoverMCP SupportVendor Lock-in RiskBest ForMaturity

LangGraphNative, graph-basedYesLowComplex stateful agent workflowsProduction-ready

AutoGenVia custom configPartialMediumMulti-agent conversationsProduction-ready

CrewAIVia LLM abstractionPartialMediumRole-based agent teamsProduction-ready

n8nVisual node routingGrowingLowNo-code/low-code automationProduction-ready

What Does the NSA AI Technology Failure Mean for Small Businesses?

You might think the NSA story has nothing to do with your 12-person company. You're more exposed, not less. The NSA can throw lawyers and alternative contractors at the problem. A small business that built its customer-support workflow entirely on one provider has no leverage and no backup when pricing triples or access changes.

Concrete opportunity: a small e-commerce firm spending $2,000/month on a single AI provider for product descriptions and support can build a two-provider router in a day, routing 70% of cheap requests to a smaller model. Real-world result: that's often a 40-60% cost reduction (~$1,000/month saved, ~$12K annually) plus outage protection.

Concrete risk: if your invoicing or client-comms automation runs on one model and that model becomes unavailable, you stop operating. For a services firm billing $40K/month, even two days of downtime is real lost revenue. The failover router above is cheap insurance against that. Build it before you need it. Our small business AI guide goes deeper on this exact tradeoff.

The smallest businesses have the most to gain from multi-provider AI — because they're the ones who can't afford a single day of being locked out.

Who Are the Prime Users of Coordinated AI Technology?

• AI/ML platform leads at mid-to-large enterprises who own the model layer and answer for uptime.

• Regulated industries — finance, healthcare, government — where provider continuity is a compliance requirement, not a preference.

• AI-native startups whose entire product is an AI workflow; for them, provider risk is existential.

• Small businesses running revenue-critical automation through tools like workflow automation platforms.

• Government and defense — the NSA is now the canonical case study for why coordination matters at the highest stakes.

What Is the Industry Impact of the AI Technology Coordination Shift — Who Wins, Who Loses?

Winners: orchestration vendors (LangChain/LangGraph, model routers), open-weight model providers (the ultimate sovereignty hedge), and the MCP ecosystem. Every team that just watched the NSA get locked out is now re-evaluating single-vendor lock-in — and that re-evaluation flows directly into demand for the coordination layer.

Losers: any strategy premised on permanent, frictionless access to a single frontier provider. Gartner estimates over $100B in annual enterprise AI spend carries single-vendor dependency risk — and the NSA event is exactly the kind of headline that moves procurement committees.

What changes for builders: 'which model is best' becomes a less important question than 'which models, behind what router, with what governance.' The center of gravity in AI technology architecture shifts from model selection to orchestration. I'd bet on that shift being permanent.

Before/after: the industry is shifting from single-provider stacks (fragile to disputes like the Anthropic-NSA situation) to coordinated orchestration layers that treat models as swappable commodities.

What Are Industry Experts Saying About the AI Technology Coordination Gap?

The reporting itself comes from The New York Times, which framed the loss of access as occurring amid the Trump administration's brawl with Anthropic. Anthropic's own public posture on responsible deployment is documented across its official documentation.

Among AI systems practitioners, the consensus reaction has been less about politics and more about architecture. Andrew Ng, founder of DeepLearning.AI and a co-founder of Google Brain, has repeatedly argued in his writing on AI engineering that the durable advantage is in the system you build around models, not the model itself. The NSA event is a textbook validation of that view — one that's now very hard to argue against.

Harrison Chase, co-founder and CEO of LangChain, has long advocated for model-agnostic orchestration as the foundation of resilient AI systems — exactly the Layer 2 pattern this article describes. And researchers publishing on arXiv have documented the brittleness of single-provider agent pipelines, where one upstream failure cascades through the entire chain. The NSA event is just the most visible data point in a pattern that's been there the whole time.

What Are the Most Common AI Technology Coordination Mistakes — And How Do You Fix Them?

  ❌
  Mistake: Optimizing only for model capability

Teams pick the highest-benchmark model and hardcode it everywhere. When access is lost — pricing, policy, or a vendor dispute like the Anthropic situation — the entire workflow dies. Capability was never the bottleneck; coordination was.

  ✅

Fix: Build the orchestration layer (LangGraph or a model router) before scaling. Treat every model as swappable from day one.

  ❌
  Mistake: Tools coupled to one model's API shape

Tool integrations written against one provider's function-calling format require a full rewrite to switch models — turning a config change into a multi-week migration. We burned two weeks on this exact problem before standardizing on MCP.

  ✅

Fix: Standardize tools behind MCP so the integration surface is model-agnostic.

  ❌
  Mistake: No governance for failover

A team builds technical failover but can't prove to auditors that the backup provider's outputs meet compliance — so they can't actually use the failover when it matters. Technical resilience that's legally unusable isn't resilience.

  ✅

Fix: Run eval suites against every provider and keep model cards on file. Make failover legally survivable, not just technically possible.

  ❌
  Mistake: Never testing the failover path

A secondary provider is configured but never exercised. When the primary fails for real, the untested fallback path breaks too — silent failure compounding silent failure. I've seen this happen in production more than once.

  ✅

Fix: Run chaos drills — deliberately revoke the primary in staging weekly and confirm traffic reroutes cleanly.

What Are the Good Practices for Resilient AI Technology?

• Always run at least two providers in production for any revenue-critical AI path.

• Abstract tools behind MCP so model swaps are configuration, not rewrites.

• Route by cost and capability — cheap models for easy tasks, frontier models for hard ones.

• Log provider identity on every request for audit and debugging.

• Run weekly failover chaos drills. If you haven't broken your primary intentionally, you don't know if your fallback works.

• Keep an open-weight model as your sovereignty hedge — the only access nobody can revoke is the one you host yourself.

• Document contractual exit terms with every provider before you depend on them.

How Much Does Resilient AI Technology Cost to Implement?

Closing the AI Coordination Gap is remarkably cheap relative to the risk it mitigates:

• Orchestration framework: LangGraph and AutoGen are open source — $0 in licensing.

• Second provider: pay-as-you-go API pricing typically runs from ~$0.25 to ~$15 per million tokens depending on model tier. Cost-based routing usually reduces total spend by sending most traffic to cheaper models.

• No-code option: n8n self-hosted is free; cloud tiers start in the low tens of dollars per month.

• Engineering cost: a basic failover router is a 1-2 day build for one engineer. The governance layer adds a few more days — call it a week total if you're being thorough.

• Total cost of ownership: for most small businesses, well under $200/month of incremental spend — against potentially tens of thousands in avoided downtime.

What Happens Next for AI Technology Resilience? (Future Projections)

2026 H2


  **Procurement teams mandate multi-provider clauses**

Following the highly public NSA-Anthropic access loss reported by NYT, expect enterprise RFPs to require demonstrated failover and exit terms as standard. This shift is already happening in conversations I'm seeing across procurement and legal teams.

2027


  **MCP becomes the default integration standard**

With MCP adoption accelerating, model-agnostic tooling becomes the expected architecture, making provider swaps routine rather than a project.

2027-2028


  **Open-weight models become the sovereignty default for critical workloads**

Organizations with mission-critical needs — especially government and regulated sectors — increasingly self-host as the one access path no dispute can revoke. The NSA event accelerates this by years.

Frequently Asked Questions

What is agentic AI?

Agentic AI refers to systems where an AI model doesn't just respond to a single prompt but autonomously plans, calls tools, makes decisions, and pursues multi-step goals. Frameworks like LangGraph, AutoGen, and CrewAI orchestrate these agents. An agent might read an email, query a database via MCP, draft a reply, and route it — all without per-step human intervention. The catch, as the NSA event shows, is that agentic systems built on a single model provider inherit the full risk of the AI Coordination Gap: if access to the underlying model is lost, the entire agent stops. Production agentic systems should run multi-provider failover to stay resilient. Browse our AI agent library for resilient templates.

How does multi-agent orchestration work?

Multi-agent orchestration coordinates several specialized AI agents — each with a role, tools, and context — toward a shared goal. A planner agent might decompose a task, hand subtasks to worker agents, and a critic agent reviews output. LangGraph models this as a stateful graph; CrewAI uses role-based crews. The orchestration layer also handles routing across model providers — the key to closing the AI Coordination Gap. Critically, the math compounds against you: a six-step agent pipeline where each step is 97% reliable is only about 83% reliable end-to-end (0.97^6 ≈ 0.83), so robust orchestration includes retries, validation, and failover. You can explore multi-agent systems patterns to build reliable pipelines.

What companies are using AI agents?

AI agents are now deployed across government, finance, healthcare, and tech. Government agencies — including, per NYT reporting, the NSA — have integrated frontier models into operational workflows. Enterprises use OpenAI and Anthropic models behind orchestration layers for customer support, code generation, and document processing. McKinsey's 2025 research shows the majority of enterprises now run AI in production. The common thread among the resilient ones: they treat models as swappable resources behind a coordination layer rather than hardcoding a single vendor. You can review enterprise AI deployment patterns for examples.

What is the difference between RAG and fine-tuning?

RAG (Retrieval-Augmented Generation) retrieves relevant documents from a vector database like Pinecone at query time and injects them into the model's context — keeping knowledge current and auditable without retraining. Fine-tuning adjusts the model's weights on your data, baking in style or domain behavior permanently. RAG is cheaper, faster to update, and easier to govern; fine-tuning excels at consistent formatting and specialized tasks. Crucially for the AI Coordination Gap: RAG is model-agnostic — your knowledge base survives a provider switch — while fine-tuned weights are locked to one provider, deepening vendor dependency. Most resilient stacks favor RAG plus light fine-tuning only where necessary. See our RAG guide for implementation.

How do I get started with LangGraph?

Install LangGraph with pip install langgraph, then read the official LangChain documentation. Start by defining a simple state graph: nodes are functions (model calls or tools), edges define flow, and conditional edges enable branching and failover. Begin with a single-agent graph, confirm it runs, then add a second model provider as a fallback node — this immediately closes the orchestration layer of the AI Coordination Gap. Add a checkpointer for persistence so long-running agents survive restarts. The official quickstart takes about 30 minutes. For production templates with multi-provider routing and MCP tool integration already wired up, explore our AI agent library.

What causes AI technology failures in production?

The most instructive AI technology failures aren't hallucinations — they're coordination failures. The June 2026 case where the NSA lost access to a powerful Anthropic model amid a Trump administration dispute, per The New York Times, is the canonical example: a capability lost not to a technical fault but to a broken vendor relationship. Other recurring failures include cascading errors in long agent chains (97% per-step reliability still yields ~83% over six steps), untested failover paths that break when needed, and tool integrations so coupled to one API that switching providers takes weeks. The lesson: architect for substitution, run chaos drills, and never let revenue-critical AI depend on a single provider.

What is MCP in AI?

MCP (Model Context Protocol) is an open standard introduced by Anthropic for connecting AI models to tools, data sources, and context in a model-agnostic way. Documented in Anthropic's official docs, MCP lets you expose a database, search API, or internal tool once and have any MCP-compatible model use it — without rewriting integrations per provider. This is the single most important development for closing the AI Coordination Gap's interface layer: when your tools speak MCP, swapping the underlying model becomes a configuration change rather than a multi-week migration. It directly reduces the vendor lock-in that left the NSA exposed when its model access was revoked. MCP adoption is accelerating across major frameworks including LangGraph and CrewAI.

About the Author

Rushil Shah

AI Systems Builder & Founder, Twarx

Rushil Shah is the founder of Twarx and an AI systems builder who has spent years designing autonomous workflows, multi-agent architectures, and AI-powered business tools. He writes from real implementation experience — covering 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.