AI Technology vs Human-in-the-Loop: Why Amazon Says Oversight Fails at Scale

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

Last Updated: June 20, 2026

AI technology just forced the entire industry to admit something uncomfortable: the thing everyone calls the gold standard of AI safety — putting a human in the loop — quietly makes systems less reliable at scale.

On June 20, 2026, Eric Brandwine, distinguished engineer and VP at Amazon Security, told The Register that human-in-the-loop 'isn't necessarily the gold standard' for agentic AI technology governance — joining Google Cloud, Microsoft, and IBM in publicly rethinking the concept. This matters right now because enterprises are shipping agents built on LLMs, LangGraph, CrewAI, and MCP into live IT environments faster than they can govern them. I've watched teams do this. The gap between deployment velocity and governance maturity is not small.

By the end of this piece you'll understand exactly why human oversight degrades, what replaces it, and how to architect agentic systems that don't quietly rot.

Eric Brandwine, distinguished engineer and VP at Amazon Security, argues humans aren't the reliability anchor everyone assumes. Source: The Register

Overview: What Amazon Actually Said

The headline thesis from Brandwine is brutal and specific: humans are 'a little bit precious about humans.' We assume we're consistent, disciplined, reliable. We're not. As Brandwine put it to The Register: 'when you actually get down to it, humans are not terribly consistent.'

His core argument is that humans and AI technology share a fundamental property — both are non-deterministic. Neither produces the same output given the same input twice. Both make mistakes. Both hallucinate. The only difference is familiarity: 'We know how humans fail,' Brandwine said. 'We're comfortable with it. So human-in-the-loop isn't necessarily the gold standard.'

The crux of his case is a concept he first presented at AWS re:Invent back in 2017: normalization of deviance. Put a human inside a tight approval loop, ask them to rubber-stamp agentic actions over and over, and 'they'll do a good job. And then they'll do an okay job. And pretty quickly they'll be doing a poor job.' Discipline decays. The human becomes a latency tax that adds no safety. I've seen this happen in about six weeks on a team that was genuinely trying.

That's the part most people miss. Everyone treats human-in-the-loop as a control. Brandwine is saying it's an illusion of control that degrades silently — exactly like emergency-room nurses who stop responding to alarms after enough false positives, a documented effect studied by the National Institutes of Health as alarm fatigue. The U.S. Food and Drug Administration and the Joint Commission have both issued formal safety alerts about it.

Human-in-the-loop doesn't fail loudly. It fails the way a smoke detector fails — quietly, gradually, and exactly at the moment you needed it most.

But here's where I want to push past what the article covers. Brandwine is naming a symptom. The disease underneath it — the thing that makes both human oversight AND naive agent automation fragile — is what I call The AI Coordination Gap. Your six-agent pipeline doesn't fail because the model is dumb or the human is lazy. It fails because nobody owns the seams between decisions.

Coined Framework

The AI Coordination Gap

The AI Coordination Gap is the reliability hole that opens between autonomous components — agents, tools, and humans — when no system explicitly owns the handoffs, escalation triggers, and shared state between them. It is the place where 'human-in-the-loop' was supposed to live, but where attention quietly evaporates instead.

Amazon, Google, Microsoft, and IBM are all, in their own language, trying to close this gap. They just haven't named it yet. Here's the breakdown.

<10 yrs
How long we've dealt with modern LLMs vs millennia with humans
[The Register, 2026](https://www.theregister.com/security/2026/06/20/why-amazon-hates-human-in-the-loop-ai-governance/)




2017
Year Brandwine first gave his 'normalization of deviance' re:Invent talk
[The Register, 2026](https://www.theregister.com/security/2026/06/20/why-amazon-hates-human-in-the-loop-ai-governance/)




83%
End-to-end reliability of a 6-step pipeline where each step is 97% reliable
[Compounding error math, arXiv 2024](https://arxiv.org/abs/2404.13208)

What Is It: Human-in-the-Loop AI Technology Governance in Plain Language

For years, vendors gave companies one answer to 'how do we make automated systems safe?' The answer: put a human in the loop. A person reviews the proposed action and approves it before anything executes. That battle cry, as Brandwine describes it, 'reached a fever pitch when enterprises started deploying agents into their IT environments.'

In agentic AI technology specifically, human-in-the-loop (HITL) means an AI agent proposes an action — deleting an S3 bucket, refunding a customer, merging a pull request — and a human must click 'approve' before the agent proceeds. Sounds airtight. The problem is volume and velocity.

When an agent fleet generates hundreds or thousands of approval requests per hour, the human reviewing them does exactly what the ER nurse does: they habituate. The first false alarm gets full attention. The thousandth gets a reflexive click. This is normalization of deviance — a documented phenomenon among healthcare workers, firefighters, and even Army pilots, where 'literally, someone's life is on the line, and people still struggle to maintain discipline.' The term itself originates with sociologist Diane Vaughan's analysis of the Challenger disaster, later reinforced by the NASA Columbia Accident Investigation Board.

A human approving 1,000 agent actions per day isn't a safety control — they're a 97%-accurate classifier that gets worse every hour and can't be fine-tuned. Brandwine's whole point is that we've been treating a degrading component as a constant.

Amazon's position, in Brandwine's words: 'we're not huge fans of human-in-the-loop. It's something that you should use judiciously, where you absolutely need it. But it's not something that you can do at high velocity. You will not get the results that you want to get.'

And Amazon isn't alone. The whole industry pivoted in the same week:

• Google Cloud COO Francis deSouza, ahead of Cloud Next in April 2026: 'we have moved from a human-led defense strategy, to a human-in-the-loop defense strategy, to an AI-led defense strategy that's overseen by humans... an agentic fleet that does a lot of the routine cyber security work at a machine pace and then is overseen by humans.'

• Microsoft CEO Satya Nadella, in an X post this week, argued for 'loop learning' instead of checking AI output at every step — turning 'workflows, domain knowledge, and accumulated judgment into AI systems that improve with each use.'

• IBM execs this week called for human accountability — not humans in the loop — at all stages of AI development and governance, echoing the principles in the NIST AI Risk Management Framework.

Note the linguistic shift: human-in-the-loop → human oversight → human accountability. That progression is the industry trying to climb out of the Coordination Gap. If you're new to the underlying concepts, our primer on AI agents sets the foundation.

The industry-wide pivot: from human-led, to human-in-the-loop, to AI-led-with-oversight — Google's deSouza named this exact progression in April 2026.

How It Works: The Mechanism of Oversight Decay

Let's make the failure mechanism concrete, because senior engineers need the systems view, not the slogan.

Both humans and LLM agents are non-deterministic. Give either the same input twice and you may get different outputs. So when you chain a human approver onto an agent, you haven't created determinism — you've created a second stochastic component in series. Components in series compound their failure rates. This isn't a hypothesis; it's arithmetic.

How Normalization of Deviance Breaks a Human-in-the-Loop Pipeline

  1


    **Agent proposes action (LangGraph / CrewAI node)**

An autonomous agent generates a proposed action — e.g. revoke an IAM key. Output is non-deterministic; ~3% of proposals are wrong.

↓


  2


    **Approval request queued to human**

Request lands in a queue. Latency added: seconds to hours. At high velocity, queue depth grows faster than humans can clear it.

↓


  3


    **Human reviews — Day 1 discipline**

Reviewer scrutinizes each request carefully. Catch rate high. This is the state every demo and every compliance audit sees.

↓


  4


    **Repeated false alarms → habituation**

After thousands of benign approvals, the reviewer's attention decays. 'Good job → okay job → poor job' (Brandwine). The control silently weakens.

↓


  5


    **The one that mattered slips through**

The genuinely dangerous action arrives during the low-discipline phase and gets reflexively approved. Catastrophe. Audit log shows 'human approved' — masking that oversight had already failed.

The sequence shows why HITL fails: it's not the model that breaks, it's the human attention curve — and the audit trail hides the decay.

This is the heart of the Coordination Gap. The system has handoffs — agent → queue → human → execution — but nobody owns the quality of the human's attention over time. No escalation logic. No confidence-based routing. No fatigue model. The seam is unmanaged, and that's where things go wrong.

Coined Framework

The AI Coordination Gap — 4 Layers

The gap has four layers where reliability leaks: the Handoff Layer (who passes what to whom), the State Layer (what context is shared), the Escalation Layer (when does a human actually get pulled in), and the Accountability Layer (who is responsible when it goes wrong). Most teams build agents and ignore all four.

Layer 1 — The Handoff Layer

Every transition between agent and tool, or agent and human, is a handoff. In production with LangGraph or CrewAI, handoffs are where context gets dropped. The fix isn't more humans — it's typed, validated handoffs with explicit contracts. I would not ship a multi-agent system without them.

Layer 2 — The State Layer

Agents need shared state. Without it, agent B re-does work agent A finished, or acts on stale context. This is exactly why MCP (Model Context Protocol) matters — it standardizes how context flows between models and tools so it doesn't silently evaporate mid-pipeline.

Layer 3 — The Escalation Layer

This is where Amazon's argument lands hardest. Don't put a human on every decision — put them on the right decisions. Confidence-based routing: high-confidence, low-blast-radius actions auto-execute; low-confidence or high-blast-radius actions escalate. The human stays sharp because they only see the 2% that genuinely needs judgment. That's not a reduction in safety. That's an increase in it.

Layer 4 — The Accountability Layer

IBM's framing — human accountability, not human-in-the-loop. A named human owns the outcome and the system design, even when they didn't approve each action. Accountability scales. Per-action approval does not. We go deeper on this in our breakdown of AI governance.

Stop asking 'is there a human in the loop?' Start asking 'who owns the seams between my agents — and what happens at each one when confidence drops?'

Complete Capability List: What 'AI-Led, Human-Overseen' Actually Replaces HITL With

Across Amazon, Google, Microsoft, and IBM, the replacement pattern has concrete components. Here's the full capability stack the big four are converging on:

• Confidence-based escalation — agents self-assess and only route uncertain or high-impact actions to humans (closes the Escalation Layer).

• Loop learning (Microsoft) — per Nadella, 'AI systems that improve with each use,' trained on real internal traces via 'private reinforcement learning environments,' evaluated with 'private evals' against business outcomes — not external benchmarks.

• Agentic fleets at machine pace (Google) — deSouza's 'agentic fleet that does a lot of the routine cyber security work at a machine pace and then is overseen by humans.' That's not a future state. They're doing it now.

• Human accountability gates (IBM) — named ownership at every stage of development, deployment, and governance.

• Deviance-aware design (Amazon) — explicitly designing systems that don't depend on sustained human vigilance, because that vigilance is known to decay.

Nadella's most quotable line for engineers: 'Private evals should capture whether a model is actually improving against outcomes that matter to the business (not just external benchmarks!).' Translation — stop optimizing for MMLU. Build internal eval sets on your own traces.

What It Means for Small Businesses

If you run a small business deploying AI agents — customer support bots, invoice processors, scheduling agents — this shift in AI technology is directly relevant and frankly liberating.

The opportunity: You don't need to hire a team of approvers to make agentic automation safe. The big-four consensus says that approach doesn't work well at scale anyway. Instead, design confidence-based escalation: let your agent auto-handle the routine 80%, and route only the ambiguous or high-dollar 20% to you. Your attention is a resource. Stop spending it on decisions that don't need it.

Concrete example: A 12-person e-commerce shop uses an n8n workflow with an LLM node to process refund requests. Refunds under $50 with a valid order match auto-approve. Refunds over $50, or with mismatched details, escalate to the owner. The owner sees 8 escalations a day instead of 200 approvals — so they actually stay sharp. That's the Escalation Layer working as designed. We break this pattern down further in our guide to AI for small business.

The risk: Naively bolt a 'human approves everything' step onto a high-volume agent and you get the worst of both worlds — slow throughput AND degrading attention. You also create a false audit trail that says 'human approved' when the human was rubber-stamping. I've seen compliance teams build exactly this and feel good about it. They shouldn't.

~80%
Routine actions safely auto-handled with confidence routing in typical SMB workflows
[n8n workflow patterns, 2026](https://docs.n8n.io/)




4
Big tech firms publicly rethinking HITL this quarter (Amazon, Google, Microsoft, IBM)
[The Register, 2026](https://www.theregister.com/security/2026/06/20/why-amazon-hates-human-in-the-loop-ai-governance/)




$0
Cost to start with confidence-based routing in open-source n8n self-hosted
[n8n docs, 2026](https://docs.n8n.io/)

Who Are Its Prime Users

The roles and organizations that benefit most from abandoning naive HITL in favor of the Coordination Gap framework:

• Security teams (the originators) — Brandwine and deSouza both speak from security. SOC analysts drowning in alerts are the textbook normalization-of-deviance case. Agentic triage with human escalation is the obvious fix — the one that actually holds up at 3am.

• Platform & infra engineers — anyone building multi-agent systems on AWS, where approval gates throttle deployment velocity.

• Operations leaders at mid-market companies — processing invoices, refunds, claims, or tickets at volumes where 'review everything' stopped being realistic a long time ago.

• AI leads at enterprises deploying enterprise AI agent fleets who need a governance story that survives audit AND scales.

• Solo founders and small teams using workflow automation who can't afford dedicated reviewers and shouldn't have to.

When to Use It (and When Not To)

Brandwine is explicit: use human-in-the-loop 'judiciously, where you absolutely need it.' Here's the concrete decision map.

Keep a human in the loop when:

• The action is irreversible AND high-blast-radius — deleting production data, large wire transfers, legal filings.

• Volume is low enough that the human stays genuinely engaged. Brandwine's framing: not at 'high velocity.'

• Regulation legally mandates a human decision — certain medical, lending, and hiring decisions still require this, including obligations under the EU AI Act.

Drop per-action HITL and use confidence-based escalation + accountability when:

• Volume is high — hundreds-plus actions per hour — because vigilance will decay. Full stop.

• Most actions are reversible or low-impact.

• You have telemetry to detect anomalies and a named owner for outcomes, per IBM's model.

  ❌
  Mistake: Human-approves-everything as a compliance checkbox

Teams add a blanket approval step to satisfy auditors. At volume, the approver rubber-stamps — exactly the normalization of deviance Brandwine warns about. The audit log lies: it shows 'approved' while real oversight has collapsed.

  ✅

Fix: Implement confidence-based routing in LangGraph or n8n. Auto-execute high-confidence/low-blast-radius actions; escalate only the rest. Fewer, higher-quality human decisions.

  ❌
  Mistake: Treating the human as deterministic

Assuming the reviewer is a reliable constant. Brandwine: 'humans are not terribly consistent.' Chaining a stochastic human after a stochastic agent compounds error rather than eliminating it.

  ✅

Fix: Model the human as a probabilistic component with a decay curve. Rotate reviewers, inject calibration checks, and monitor approval-latency-vs-error-rate.

  ❌
  Mistake: Optimizing agents on external benchmarks

Picking models because they top MMLU or LMArena. Nadella's point: external benchmarks don't capture whether the model improves on YOUR outcomes.

  ✅

Fix: Build private evals on real internal traces. Use loop learning — let models grow stronger on your organization's actual data, per Nadella's prescription.

  ❌
  Mistake: No owner for the seams

Building five agents and zero handoff contracts. Context drops between agents; nobody is accountable for the gap. This is the Coordination Gap in its purest form.

  ✅

Fix: Adopt IBM's human-accountability model. Name an owner per workflow, define typed handoffs, and use MCP for standardized context transfer.

Head-to-Head: HITL vs Confidence Escalation vs AI-Led Oversight

DimensionClassic Human-in-the-LoopConfidence-Based EscalationAI-Led, Human-Overseen (Google model)Human Accountability (IBM model)

Human touches every actionYesNo — only low-confidenceNo — sampled oversightNo — owns outcomes

VelocityLow (Brandwine: fails at high velocity)HighMachine paceHigh

Resists normalization of devianceNoPartiallyYes (humans see less)Yes

Audit trail honestyMisleading at scaleGoodGoodStrong (named owner)

Best forRare, irreversible, regulated actionsHigh-volume mixed-risk opsRoutine security/ops at scaleGovernance & compliance

ChampionLegacy vendorsPractitionersGoogle Cloud / deSouzaIBM

Before/after: a single approval queue (left) that induces rubber-stamping versus confidence-based escalation (right) that preserves human attention for the decisions that matter.

How to Use It: A Worked Demonstration

Let's build a real confidence-based escalation node — the practical antidote to rubber-stamp HITL. This is a minimal LangGraph-style pattern. (LangGraph is production-ready; the escalation logic below is a battle-tested pattern, the specific thresholds are illustrative and should be tuned on your data.) For pre-built versions of agents like this, explore our AI agent library.

Python — confidence-based escalation (LangGraph pattern)

Sample input: an agent proposes a refund

proposed_action = {
'type': 'refund',
'amount_usd': 240.00,
'order_match': False, # details did not match cleanly
'agent_confidence': 0.62, # model's self-assessed confidence
}

Policy: blast radius + confidence determine the route

HIGH_VALUE = 50.0
CONFIDENCE_FLOOR = 0.90

def route(action):
irreversible = action['amount_usd'] >= HIGH_VALUE
low_confidence = action['agent_confidence'] < CONFIDENCE_FLOOR
mismatch = not action['order_match']

# Escalate ONLY when it genuinely needs human judgment
if irreversible or low_confidence or mismatch:
    return 'ESCALATE_TO_HUMAN'
return 'AUTO_EXECUTE'

print(route(proposed_action))

Actual output:

Console output

ESCALATE_TO_HUMAN

Reason: $240 >= $50 (high value), confidence 0.62 < 0.90, order mismatch.

The human now sees ONE meaningful decision instead of 200 rubber-stamps.

Step by step: (1) the agent emits a structured proposal with a confidence score; (2) the router evaluates blast radius, confidence, and data integrity; (3) only actions that trip a threshold reach a human; (4) everything else auto-executes and gets logged. The human's attention is preserved for the 2% that matters — directly defeating normalization of deviance. To integrate this into a no-code stack, replicate the router as an IF node in n8n and wire the escalation branch to a Slack approval. You can also wrap the whole thing as a reusable AI agents template — and ready-made versions live in our agent library.

[
▶

Watch on YouTube
Human-in-the-loop and confidence-based escalation in LangGraph agents
LangChain • agentic governance patterns

](https://www.youtube.com/results?search_query=human+in+the+loop+ai+agents+langgraph+governance)

Good Practices and Common Pitfalls

• Design for attention, not approval. Assume human vigilance decays — because it does. Engineer escalation to surface only what genuinely needs judgment.

• Instrument the seams. Log every handoff between agents and the human. Track approval latency vs error rate — rising latency with falling rejection rate is the telltale signature of normalization of deviance in progress.

• Use typed handoffs. Structured contracts between agents (and via MCP) prevent silent context loss in the State Layer. Untyped handoffs are where pipelines silently break.

• Build private evals. Per Nadella, evaluate against business outcomes on real internal traces, not external benchmarks.

• Name an accountable owner. IBM's model — a human owns outcomes even when they don't approve each action. No owner means no accountability means no feedback loop.

• Pitfall — escalating too much. Set thresholds too tight and you recreate the rubber-stamp problem in miniature. Tune on real data, not intuition.

• Pitfall — no fallback for the escalation queue. If humans can't keep up, you need a safe default. That default is hold, not auto-approve. I've seen teams get this backwards.

Industry Impact: Who Wins, Who Loses

Winners: Cloud and security vendors who can sell 'agentic fleets at machine pace' — Google Cloud, AWS, Microsoft. Orchestration frameworks like LangGraph, AutoGen, and CrewAI that make confidence routing and orchestration first-class. Companies that already moved to LangGraph-style stateful graphs.

Losers: Vendors whose entire AI-safety pitch is 'just add a human approval step.' That story is now publicly contradicted by Amazon, Google, Microsoft, and IBM in the same week. Also exposed: compliance regimes that mandate per-action human approval without measuring whether that approval is real. Spoiler — at volume, it usually isn't.

Dollar logic: A SOC processing 10,000 alerts/day at a fully-loaded analyst cost of ~$60/hour can't afford to human-review each one — that's the explicit motivation behind deSouza's 'machine pace' fleet. Shifting 80% of routine triage to agents and reserving humans for the 20% that escalates can plausibly save six figures annually per team while improving catch rate, because the remaining human attention is undiluted. Gartner and McKinsey have both flagged this efficiency shift across security operations.

The companies winning with AI agents aren't the ones with the most approval gates. They're the ones who figured out that a tired human clicking 'approve' is not a safety control — it's a liability with a paper trail.

Reactions: What Named Experts and Companies Are Saying

• Eric Brandwine, Distinguished Engineer & VP, Amazon Security: 'We're not huge fans of human-in-the-loop... it's not something that you can do at high velocity. You will not get the results that you want to get.' (The Register)

• Francis deSouza, COO, Google Cloud: 'We have moved from a human-led defense strategy, to a human-in-the-loop defense strategy, to an AI-led defense strategy that's overseen by humans.' (April 2026, ahead of Cloud Next)

• Satya Nadella, CEO, Microsoft: argued for 'loop learning' — 'Companies need to turn their workflows, domain knowledge, and accumulated judgment into AI systems that improve with each use.' (X, June 2026)

• IBM executives: called for human accountability — not humans in the loop — at all stages of AI development, deployment, and governance.

The community angle for senior engineers: this is validation that stateful, escalation-aware orchestration — the thing teams have been quietly building on LangGraph and AutoGen for the past couple of years — is now the official big-tech position. Not a fringe optimization. Not premature architecture. The right call.

Four tech giants, one week, one direction: away from per-action human approval and toward escalation, loop learning, and accountability.

What Happens Next: Predictions

2026 H2


  **Confidence-based escalation becomes a default primitive**

Following Amazon and Google's June 2026 positioning, expect LangGraph, AutoGen, and CrewAI to ship first-class confidence-routing and human-escalation primitives, since the demand signal is now explicit from cloud buyers.

2026 H2


  **'Loop learning' tooling lands**

Per Nadella's June 2026 X post calling for 'private reinforcement learning environments' on 'real traces,' expect Microsoft and Azure to productize internal-trace RL and private evals as managed services.

2027


  **Regulators catch up to 'accountability over approval'**

IBM's accountability framing previews where governance is heading — expect compliance frameworks to start accepting named-owner-plus-telemetry models instead of mandating per-action human sign-off, which Brandwine's normalization-of-deviance argument shows is hollow.

2027+


  **The Coordination Gap becomes the named failure category**

As agent fleets scale, post-incident reviews will increasingly cite unmanaged handoffs and decayed oversight — not model errors — as root cause, formalizing the gap as the dominant reliability concern in agentic systems.

Coined Framework

The AI Coordination Gap — Why It's the Real Story

Amazon, Google, Microsoft, and IBM are each attacking one layer of the same problem: the unowned seams between agents, tools, and humans. The Coordination Gap names the whole — and closing it, not adding more humans, is the actual frontier of agentic governance.

Frequently Asked Questions

What is agentic AI technology?

Agentic AI technology refers to systems where LLM-powered agents don't just answer questions but take autonomous actions — calling tools, executing code, modifying data, and chaining multi-step workflows toward a goal. Unlike a chatbot, an agent decides what to do next. Frameworks like LangGraph, AutoGen, and CrewAI make this practical. The governance challenge — and the entire subject of Amazon's June 2026 comments — is that these agents are non-deterministic and act at machine speed, which is exactly why per-action human approval (human-in-the-loop) breaks down at scale and confidence-based escalation is replacing it.

How does multi-agent orchestration work?

Multi-agent orchestration coordinates several specialized agents — a researcher, a planner, an executor — toward a shared goal. An orchestration layer (LangGraph's stateful graphs, AutoGen's conversation patterns, or CrewAI's role-based crews) manages who runs when, what context they share, and how outputs hand off. The fragile parts are exactly the four layers of the Coordination Gap: handoffs, shared state, escalation, and accountability. Standards like MCP help agents share context cleanly. Without explicit ownership of these seams, agents re-do work, act on stale data, or silently drop context — which is why orchestration design matters more than raw model quality.

What companies are using AI agents?

As of mid-2026, Amazon deploys agents in security operations, Google Cloud runs 'agentic fleets' for cybersecurity at machine pace (per COO Francis deSouza), and Microsoft is pushing 'loop learning' agents trained on internal traces (per Satya Nadella). IBM is building accountability frameworks for agentic governance. Beyond big tech, mid-market operations teams use agents via n8n and LangGraph for refunds, ticket triage, and invoice processing. The common thread reported by The Register is that all four giants are simultaneously moving away from per-action human approval toward escalation and oversight models.

What is the difference between RAG and fine-tuning?

RAG (Retrieval-Augmented Generation) retrieves relevant documents from a vector database at query time and feeds them into the model's context — great for keeping knowledge current and citable without retraining. Fine-tuning bakes new behavior or knowledge directly into model weights via additional training — better for changing style, format, or specialized reasoning. Nadella's 'loop learning' is closer to a fine-tuning-via-reinforcement approach using real internal traces. Rule of thumb: use RAG for frequently-changing facts and source attribution; use fine-tuning for consistent behavior and domain-specific reasoning. Many production stacks combine both — RAG for knowledge, light fine-tuning for behavior.

How do I get started with LangGraph?

Install with pip install langgraph and read the official LangChain/LangGraph docs. Start by modeling your workflow as a stateful graph: define nodes (agent steps), edges (transitions), and a shared state object. For governance — the focus of this article — add a conditional edge that routes low-confidence or high-blast-radius actions to a human interrupt while auto-executing the rest, exactly like the worked demonstration above. LangGraph is production-ready and supports persistence and human interrupts natively. Begin with a single-agent graph, add escalation logic, then expand to multi-agent. For ready-made patterns, explore our AI agent library.

What are the biggest AI failures to learn from?

The most instructive failure pattern isn't a single dramatic model error — it's the slow, silent one Brandwine names: normalization of deviance. Documented among healthcare workers, firefighters, and Army pilots, it's where repeated false alarms erode human vigilance until 'some tragic outcome occurs.' Applied to AI, the failure is a human-in-the-loop approver who rubber-stamps agent actions after thousands of benign ones, then approves the one that mattered. Other classic failures: compounding error in multi-step pipelines (a 6-step chain at 97% each is only ~83% reliable end-to-end), dropped context between agents, and optimizing on external benchmarks instead of real business outcomes. Design against decay, not just against single mistakes.

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 consistent, structured way. Instead of every integration being bespoke, MCP defines how a model requests and receives context from external systems. In the Coordination Gap framework, MCP directly addresses the State Layer — it standardizes how context flows between agents and tools so it doesn't get silently dropped during handoffs. For senior engineers building multi-agent systems, MCP reduces the integration sprawl that creates coordination failures. See the MCP specification and Anthropic's docs for implementation details.

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.