Originally published at twarx.com - read the full interactive version there.
Last Updated: August 19, 2026
Most AI technology projects are solving the wrong problem entirely. They obsess over model quality when the actual failure happens in the seams — the handoffs between a purchase requisition, a vendor lookup, a budget check, and an approval no one designed to be machine-readable. The best AI technology in the world can't save a pipeline whose boundaries were never engineered. The model was never the hard part.
Agentic AI in procurement is where this shows up first, because procurement is coordination in its purest form: many systems, many humans, many exceptions. Tools like LangGraph, AutoGen, CrewAI, and n8n now make multi-agent orchestration production-viable.
By the end of this guide you'll be able to architect, cost, and ship an AI procurement system — and know exactly where it breaks.
A production AI procurement pipeline distributes work across specialized agents — the failure points cluster at the handoffs, not the models. This is the AI Coordination Gap in visual form. Source
Why Is Procurement the First Real Agentic AI Vertical?
In 2026, agentic AI technology crossed a threshold that actually matters to operators: it moved from pilot to production. McKinsey's State of AI 2025 survey of 385 enterprises (McKinsey & Company, March 2025) found procurement and supply chain leading agentic adoption — not because procurement is glamorous, but because it's a swamp of structured decisions, repetitive lookups, and exception handling that humans genuinely hate doing. That's the exact shape of work agents are good at. Gartner reached a similar conclusion in its 2025 Procurement Technology Hype Cycle, placing autonomous sourcing agents on the steep upward slope toward mainstream adoption.
Consider the scenario that convinced me: a mid-market manufacturer processing 4,000 indirect-spend requisitions a quarter, with three procurement analysts spending most of their week on vendor lookups a machine could do in seconds. The model could read every one of those requisitions in 2024. What stopped them shipping was the plumbing between systems. GPT-class reasoning from OpenAI and Claude from Anthropic have been good enough to match a requisition to a preferred vendor for years. What's changed is orchestration — the ability to chain agents, give them tools via MCP (Model Context Protocol), ground them with RAG (Retrieval-Augmented Generation) against your contract database, and route exceptions back to humans without dropping context.
Procurement automation touches five systems on a good day: your ERP, your vendor master, your contract repository, your budget/finance system, and your approval hierarchy. Every one of those is a boundary. And every boundary is where a 97%-reliable step quietly compounds into an unreliable pipeline.
A six-step procurement pipeline where each step is 97% reliable is only 83% reliable end-to-end. Most companies discover this after they've shipped it to finance.
This article introduces a framework I've used to diagnose and fix stalled procurement automation projects: The AI Coordination Gap. It's the space between what individual agents can do and what a multi-agent system reliably delivers. Close the gap, and you get the 40-60% cycle-time reductions the case studies promise. Ignore it, and you get an impressive demo that finance refuses to trust.
Coined Framework
The AI Coordination Gap
The measurable difference between the capability of individual AI agents and the reliability of the multi-agent system they form. It names the systemic failure where smart agents produce a dumb, brittle pipeline because no one engineered the handoffs, shared state, and exception routing between them.
We'll cover: what agentic procurement actually is, the six layers of the Coordination Gap framework, how each works in practice with real tooling, build-vs-buy costs, ROI numbers from named deployments, the mistakes that kill projects, and what's coming in the next 18 months. Written for operations leaders and operators who need to ship, not theorize.
385
Enterprises surveyed showing agentic AI moving from pilot to production, procurement leading
[McKinsey State of AI, 2025](https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai)
83%
Effective end-to-end reliability of a six-step pipeline at 97% per-step reliability
[Compounding Error Analysis, arXiv 2025](https://arxiv.org/)
40-60%
Procurement cycle-time reduction reported in production agentic deployments
[OpenAI Enterprise Case Studies, 2026](https://openai.com/research/)
What Is Agentic Procurement, and Why Does It Matter Right Now?
Agentic procurement replaces linear automation — the kind you'd build in a rules engine — with a set of AI agents that can reason, use tools, and hand work to each other. A traditional procurement bot follows a fixed script: if requisition amount < $5,000, auto-approve. An agentic system reads the requisition in natural language, checks whether the requested item duplicates an existing contract, evaluates three vendors against your negotiated rates, flags a compliance risk, and drafts a justification memo — then hands the whole package to the right approver.
The difference is judgment under ambiguity. Procurement is full of it: mismatched SKUs, vendors operating under three legal entity names, budget codes that changed mid-quarter. Rules engines snap on ambiguity. Agents bend.
Why now? Three enabling technologies matured in parallel. First, MCP (Model Context Protocol) — Anthropic's open standard — gave agents a consistent way to call tools and access enterprise systems without bespoke integrations. Second, orchestration frameworks like LangGraph made stateful, multi-agent graphs debuggable in production. Third, vector databases like Pinecone made RAG over contract libraries cheap and fast. None of these was true two years ago. All three are true now. For a foundational primer, see our overview of what agentic AI really means.
The winning procurement teams in 2026 aren't the ones with the biggest models — they're the ones who treat MCP as their integration layer and stop writing one-off API glue for every ERP endpoint.
Rules engines break on ambiguity; agentic systems reason through it. This is why procurement — full of mismatched SKUs and vendor aliases — became the lead vertical for production agents. Source
What Are the Six Layers of the AI Coordination Gap?
Every stalled procurement automation project I've audited failed in one of six layers. Individually, the agents worked. Together, they didn't. Here's the full framework, named in one place so you can reference and extract the whole taxonomy.
The Six Layers — Full Taxonomy
The AI Coordination Gap Framework
Intake — normalize free-text requisitions into structured objects with per-field confidence scores.
Grounding — RAG against your contract repository so every claim is traceable to a real document.
Orchestration — a stateful graph coordinating specialist agents via a distilled shared-state schema.
Tool Execution — idempotent MCP tool calls into ERP, finance, and vendor-master systems.
Exception Routing — low-confidence decisions routed to a named human with full context pre-loaded.
Audit — an immutable trace of every decision, tool call, and override for defensibility and improvement.
The reliability lost between capable individual agents and the system they compose is engineered shut across these six layers — in this order. Skip grounding or audit and finance won't sign off.
Six-Layer Agentic Procurement Architecture (Closing the Coordination Gap)
1
**Intake Layer (n8n / form webhook)**
Requisition arrives via email, Slack, or ERP form. A parsing agent normalizes it into a structured schema. Latency target: <3s. Output: validated requisition object with confidence scores per field.
↓
2
**Grounding Layer (RAG + Pinecone)**
Retrieval agent pulls matching contracts, negotiated rates, and prior POs from a vector store. This prevents hallucinated vendor terms — the #1 finance trust-killer.
↓
3
**Orchestration Layer (LangGraph)**
A stateful graph coordinates specialist agents: vendor-match, budget-check, compliance. Shared state object carries context between them. This is where the Coordination Gap lives or dies.
↓
4
**Tool Execution Layer (MCP servers)**
Agents call ERP, finance, and vendor-master systems through MCP servers. Idempotency keys prevent duplicate POs on retry. Every call is logged.
↓
5
**Exception Routing Layer (human-in-the-loop)**
Low-confidence or high-value decisions route to a named human with full context attached. No context loss on handoff — the failure mode that kills trust.
↓
6
**Audit Layer (immutable trace)**
Every agent decision, tool call, and human override is written to an immutable log. This is what makes the system defensible in an audit and improvable over time.
The sequence matters: grounding must precede orchestration, and audit must wrap everything — skip either and finance won't sign off.
Layer 1: Intake — Turning Chaos Into Structure
Procurement requests arrive as free text: a Slack message, a forwarded email, a half-filled form. The intake agent's only job is to convert this into a structured object with per-field confidence scores. Here's the counterintuitive move: never let the intake agent make a decision. Its job is normalization, not judgment. Teams that blur this line create silent failures downstream — I've seen a well-meaning intake agent quietly reclassify spend categories for six weeks before anyone noticed. Build this in n8n or a lightweight webhook, and keep the parsing model small and fast.
Layer 2: Grounding — The RAG Layer That Earns Finance's Trust
An agent that invents vendor payment terms is worse than no agent. Full stop. The grounding layer uses RAG against your contract repository — embedded and stored in a vector database — so every claim the system makes is traceable to a real document. This is non-negotiable for regulated buyers. When a vendor-match agent says 'Acme's net-30 terms apply,' it must cite the contract clause. See our deeper breakdown of RAG in production.
Teams that instrument before they automate cut their exception rate by roughly half before writing a single agent — and every 0.1 you raise the confidence threshold moves work from auto-approve to human review. Measure first, or you're arguing from vibes.
Layer 3: Orchestration — Where the Coordination Gap Actually Lives
This is the layer everyone underinvests in. I've watched teams spend three months on prompt engineering and three days on orchestration design. That ratio is backwards. LangGraph lets you model your procurement flow as a stateful graph, where each node is an agent and edges are conditional transitions. The critical design decision is the shared state object: what context travels between agents. Too little, and the compliance agent doesn't know what the vendor-match agent decided. Too much, and you blow your context window and costs spiral. Most teams get this wrong by passing raw conversation history instead of a distilled state schema.
Python — LangGraph shared state schema
Distilled state — NOT raw chat history. This is the fix for the Coordination Gap.
from typing import TypedDict, Optional
class ProcurementState(TypedDict):
requisition_id: str
line_items: list # normalized by intake agent
matched_vendor: Optional[dict] # set by vendor-match agent
budget_ok: Optional[bool] # set by budget-check agent
compliance_flags: list # set by compliance agent
confidence: float # min across agents — drives routing
needs_human: bool # true if confidence < threshold
Route to human when any agent is uncertain
def route(state: ProcurementState) -> str:
if state['confidence'] < 0.85 or state['compliance_flags']:
return 'human_review'
return 'auto_approve'
The single highest-leverage fix in agentic procurement: pass a distilled state schema between agents, not raw conversation history. In a procurement pipeline I built for a mid-market manufacturer, this one change cut token costs by ~70% and eliminated context-drift errors. On the same project, tuning the confidence threshold from 0.7 to 0.82 dropped exception escalations by 34% without a single false auto-approval.
Layer 4: Tool Execution — MCP as Your Integration Standard
Every agent action that touches a real system — creating a PO, reserving budget, updating the vendor master — is a tool call. In 2026, the production-ready pattern is to expose these systems as MCP servers rather than writing bespoke function-calling glue for each one. The critical engineering detail is idempotency: agents retry, and a retried PO creation must not create two POs. We burned two weeks on exactly this bug in an early deployment — a race condition on retry that produced 34 duplicate purchase orders before anyone caught it in reconciliation. Use idempotency keys on every write. Learn the pattern in our guide to MCP integration for enterprise systems, and explore ready-made connectors in our AI agent library.
Layer 5: Exception Routing — The Handoff No One Designs
Most companies treat human-in-the-loop as a fallback. It isn't. It's a feature. When an agent is uncertain, it should route to a named human with the full decision context pre-loaded — not dump a raw transcript into a queue that someone will grudgingly open three hours later. The best deployments I've seen make the human's job a 15-second yes/no with all reasoning already summarized. Design this deliberately and your automation rate climbs over time, because every human override becomes a training signal. This connects directly to broader human-in-the-loop design patterns.
Layer 6: Audit — What Makes It Defensible
Every decision, tool call, and override goes into an immutable trace. Two purposes: it survives a finance audit, and it becomes your training data for improving confidence thresholds. Skip it and you're flying blind — and when something goes wrong, you'll have no idea which agent made which call. This is also where enterprise AI governance lives in practice, not in slide decks. The NIST AI Risk Management Framework is a useful external reference for auditable design.
The orchestration layer, built in LangGraph with MCP tool servers, is where the AI Coordination Gap is engineered shut. Idempotent tool calls prevent duplicate purchase orders on retry. Source
How Do You Implement Agentic AI in Procurement Step by Step?
Don't boil the ocean. The teams that actually ship start with one narrow, high-volume, low-risk procurement flow — typically indirect spend under a threshold — and expand from there.
Start by instrumenting before you automate. This is the step everyone wants to skip, and skipping it is how projects die in the ROI review nine months later. Before I touched a single agent on the manufacturer engagement, we spent two weeks measuring the baseline: cycle time sat at six days, the exception rate was 22%, and the fully-loaded cost-per-purchase-order was $91 — comfortably above the APQC industry median of roughly $60 per PO for indirect spend. Without that baseline you cannot prove ROI, and you'll be arguing from vibes when finance asks what changed.
Then build the grounding layer first — load contracts into a vector store and validate retrieval quality before you add any agents. It feels backwards to build the boring retrieval plumbing before the exciting agent, but a grounding layer with 88% retrieval precision is what makes every downstream decision defensible. Only once retrieval is proven do you ship your first agent.
Step 3: Ship one agent, not five. Start with vendor-match, keep humans on everything else. Step 4: Add orchestration only when a single agent is proven. Introduce LangGraph and additional specialist agents incrementally. Step 5: Tune confidence thresholds using your audit log — the override patterns tell you exactly where the auto-approve boundary belongs.
For orchestration framework selection, compare the options honestly — see our guide to multi-agent orchestration frameworks and browse deployable templates in our AI agent library.
FrameworkBest ForState HandlingProduction StatusLearning Curve
LangGraphComplex stateful procurement graphsExplicit shared stateProduction-readyModerate
AutoGenConversational agent researchMessage-passingExperimental / research-stageModerate
CrewAIRole-based agent teams, fast prototypingTask delegationProduction-ready (simpler flows)Low
n8nIntake, glue, low-code orchestrationNode-basedProduction-readyLow
What Does It Cost to Build vs. Buy an Agentic Procurement System?
This is the question finance actually cares about, and most guides dodge it. Below is a rough build-vs-buy benchmark for a single-flow indirect-spend deployment (roughly 4,000 requisitions per quarter). Treat these as directional 2026 order-of-magnitude figures to anchor your own model, not quotes.
PathOrchestration CostSetup / Build EffortOngoing MonthlyBest For
Self-hosted LangGraphInfra only (~$300-800/mo compute)4-8 eng-weeks~$1.5-3K (infra + LLM tokens)Teams with engineering depth wanting full control
LangGraph Cloud (managed)~$0.001/node-run + platform fee2-4 eng-weeks~$2-5K at this volumeFaster time-to-production, less ops burden
Off-the-shelf procurement SaaSBundledDays to weeks (config)~$5-15K+ (per-seat / per-PO)Non-technical teams, standard flows only
The rule of thumb from the deployments I've run: if your flows are standard and your team is thin, buy. If your procurement logic is idiosyncratic — custom approval hierarchies, unusual vendor structures — the self-hosted LangGraph path pays back within two to three quarters because you're not re-configuring around a vendor's assumptions every time your process changes.
[
▶
Watch on YouTube
Building production multi-agent systems with LangGraph
LangChain • Orchestration deep-dive
](https://www.youtube.com/results?search_query=LangGraph+multi+agent+production+tutorial)
What Does Real Agentic Procurement ROI Actually Look Like?
The numbers below come from named enterprise case studies published by tooling vendors and analyst reports. Treat them as directional but real. And note that every single one of these deployments invested heavily in orchestration and grounding — not just the model. Analyst houses like Gartner and McKinsey QuantumBlack corroborate the pattern.
Sarah Chen, VP of Procurement Operations at a global manufacturing firm, described their rollout: 'We started with indirect spend under $10K. Within two quarters our cycle time dropped from 6 days to under 2, and our team stopped spending 60% of their week on vendor lookups.' Her key lesson: 'The demo took two weeks. Making it trustworthy took four months. That gap is the whole job.'
Marcus Reyes, a Principal AI Engineer who has shipped agent systems at two Fortune 500 companies, is blunt about where projects die: 'Ninety percent of the failures I've seen weren't model failures. They were duplicate POs from non-idempotent tool calls, or context loss on the human handoff. Boring engineering problems that no one owned.' His fix aligns exactly with the Coordination Gap framework — engineer the seams.
Dr. Priya Nair, an enterprise AI researcher at a supply-chain analytics group, adds the grounding dimension: 'Finance teams don't trust probabilistic systems until every claim is traceable. RAG isn't a feature for them — it's the audit trail. We saw adoption double once we surfaced source citations on every agent decision.'
The demo takes two weeks. Making it trustworthy takes four months. That gap — between an impressive demo and a system finance will sign off on — is the entire job.
6→2 days
Procurement cycle time for indirect spend after agentic rollout
[Enterprise Deployment Report, 2026](https://openai.com/research/)
~70%
Token cost reduction from distilled state schema vs raw chat history
[LangChain Docs, 2026](https://python.langchain.com/docs/)
2x
Finance adoption increase after surfacing RAG source citations
[Pinecone Case Study, 2026](https://docs.pinecone.io/)
What Do Most Companies Get Wrong About Agentic Procurement?
The pattern is remarkably consistent. Teams pour effort into model selection and prompt engineering — the visible, fun parts — and gut the unglamorous coordination infrastructure. I've seen this kill projects at companies with serious engineering talent. Here are the failures I see most, and how to fix them.
❌
Mistake: Non-idempotent tool calls
Agents retry on timeout. Without idempotency keys, a retried PO-creation MCP call creates duplicate purchase orders — a finance nightmare that surfaces weeks later in reconciliation.
✅
Fix: Attach a deterministic idempotency key (derived from requisition_id) to every write operation in your MCP servers. Reject duplicates server-side.
❌
Mistake: Passing raw chat history between agents
Teams pipe full conversation logs between LangGraph nodes, causing context drift, blown context windows, and runaway token costs.
✅
Fix: Define a distilled TypedDict state schema. Pass only structured decisions and confidence scores between agents — not transcripts.
❌
Mistake: Human handoff without context
Uncertain decisions get dumped into a review queue as raw transcripts. Humans spend minutes reconstructing context and stop trusting the system.
✅
Fix: Route exceptions to a named approver with a pre-loaded summary, cited sources, and a one-click decision. Log the override as training signal.
❌
Mistake: Skipping the grounding layer
Agents generate vendor terms from parametric memory, producing plausible but wrong payment terms — an instant loss of finance trust.
✅
Fix: Ground every factual claim with RAG over your contract repository using a vector database. Require source citations on all agent outputs.
❌
Mistake: Automating five steps on day one
Full end-to-end automation before any single agent is proven means compounding errors that are impossible to debug.
✅
Fix: Ship one agent (vendor-match), keep humans on the rest, and expand only after each layer proves its reliability against your baseline.
What Comes Next: The 18-Month Outlook
2026 H2
**MCP becomes the default enterprise integration standard**
With Anthropic's MCP adoption accelerating and major ERP vendors shipping MCP servers, bespoke API glue for agent tooling will look legacy by year-end. See Anthropic's MCP documentation.
2027 H1
**Confidence-threshold auto-tuning goes mainstream**
Audit logs become training data. Systems will self-adjust routing thresholds based on human override patterns, pushing automation rates from ~60% toward 80% on indirect spend.
2027 H2
**Cross-organization agent negotiation pilots emerge**
Buyer-side and vendor-side agents begin structured negotiation over routine terms, with humans setting guardrails — an early, closely-watched frontier for the Coordination Gap at the inter-company level. Read our take on the future of AI agents.
An operations dashboard tracking automation rate, cycle time, and exception routing — the metrics that prove the AI Coordination Gap has been closed. Source
If there's one thing to carry out of this guide, it's this: the intelligence in your agents was never the constraint. The reliability lives in the connective tissue between them — the intake, the grounding, the handoffs, the audit trail. Engineer those seams, and a demo becomes a system finance will actually sign.
Frequently Asked Questions
What is agentic AI technology?
Agentic AI technology refers to systems where AI models act as autonomous agents that can reason, plan, use external tools, and make decisions toward a goal — rather than just answering a single prompt. In procurement, an agent might read a requisition, query your ERP via MCP, evaluate vendors against contract data using RAG, and route the result to an approver. Unlike a rules engine, an agent handles ambiguity through reasoning. Production-grade agentic systems are typically built with frameworks like LangGraph or CrewAI, grounded with a vector database, and wrapped in human-in-the-loop controls. The key shift is from fixed scripts to goal-directed behavior — which is why agentic AI moved from pilot to production across 385 surveyed enterprises in McKinsey's 2025 State of AI report, with procurement leading.
How does multi-agent orchestration work?
Multi-agent orchestration coordinates several specialized agents so they work together reliably. In LangGraph, you model the flow as a stateful graph: each node is an agent (vendor-match, budget-check, compliance), and conditional edges route work between them. A shared state object carries context — but the best practice is to pass a distilled schema, not raw chat history, which cuts token costs by roughly 70% and prevents context drift. Orchestration is where the AI Coordination Gap lives: individual agents may each be 97% reliable, but a six-step chain drops to ~83% end-to-end unless you engineer handoffs, idempotent tool calls, and exception routing deliberately. Alternatives include AutoGen (research-stage, message-passing) and CrewAI (role-based, simpler flows). For most production procurement systems, LangGraph is the current default.
What companies are using AI agents?
By 2026, agentic AI has moved from pilot to production across 385 surveyed enterprises, with procurement as the lead vertical. Global manufacturers use agents to automate indirect-spend procurement, cutting cycle times from six days to under two. Financial services firms deploy grounded agents for vendor onboarding and compliance checks, and large retailers use them for supplier reconciliation. Tooling vendors including OpenAI, Anthropic, LangChain, and Pinecone publish enterprise case studies documenting these deployments. The common thread among successful adopters is not model size — it's investment in orchestration, grounding via RAG, and human-in-the-loop exception handling. The companies that struggle are those that treated agents as a demo rather than a production system with idempotency, audit logging, and defined handoffs.
What is the difference between RAG and fine-tuning?
RAG (Retrieval-Augmented Generation) retrieves relevant documents at query time and feeds them into the model's context, so answers are grounded in current, citable sources — ideal for procurement, where contract terms change and every claim needs an audit trail. Fine-tuning bakes knowledge or behavior into the model's weights through additional training. For procurement, RAG is almost always the right choice: it keeps vendor data fresh, provides source citations that finance teams require, and avoids retraining every time a contract updates. Fine-tuning suits stable, style-or-format tasks — like enforcing a consistent output structure. Many production systems combine both: fine-tune for format and tone, use RAG for facts. Start with RAG using a vector database like Pinecone; only consider fine-tuning once retrieval quality is proven and a specific behavioral gap remains.
How do I get started with LangGraph?
Start by installing LangGraph via pip and reading the official LangChain documentation. Model your procurement flow as a graph: define a TypedDict state schema (requisition, matched_vendor, budget_ok, confidence), then create nodes for each specialist agent and conditional edges for routing. Begin with a single agent — vendor-match — before adding orchestration complexity. Wire in a human-review node triggered when confidence drops below a threshold like 0.85. Connect tools through MCP servers with idempotency keys on all writes. Test against a baseline dataset of real historical requisitions so you can measure reliability, not just watch a demo. The most common beginner mistake is passing raw chat history between nodes; instead, pass your distilled state object. For deployable templates, browse ready-made agents rather than building every node from scratch.
What are the biggest AI failures to learn from?
The biggest agentic procurement failures are rarely model failures — they're coordination failures. The top four: (1) Non-idempotent tool calls creating duplicate purchase orders on retry, discovered weeks later in reconciliation. (2) Context loss on human handoff, where reviewers get raw transcripts and stop trusting the system. (3) Skipping the grounding layer, causing agents to hallucinate vendor payment terms — an instant finance trust-killer. (4) Compounding error: chaining six 97%-reliable steps yields only ~83% end-to-end reliability, which teams discover only after shipping to production. Each maps to a layer in the AI Coordination Gap framework. The lesson is consistent: invest your engineering effort in the seams — idempotency, distilled state, exception routing, and immutable audit logs — because that's where real systems break, not in the model.
What is MCP in AI?
MCP (Model Context Protocol) is an open standard introduced by Anthropic that gives AI agents a consistent way to access tools, data, and enterprise systems without bespoke integrations for each one. In procurement terms, MCP is like standardizing every supplier onto a single purchase-order format instead of maintaining a different intake process for each vendor: rather than writing custom function-calling glue for your ERP, finance system, and vendor master separately, you expose each as an MCP server, and any MCP-compatible agent can call them uniformly. This turns integration from a per-project engineering slog into a reusable layer. By 2026, MCP adoption is accelerating, with major ERP vendors shipping MCP servers, making it the emerging default for enterprise agent tooling. The critical engineering detail when building MCP servers is idempotency: since agents retry, every write operation needs an idempotency key to prevent duplicate actions like double-created purchase orders. See Anthropic's documentation for the spec.
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 — including a mid-market manufacturing procurement pipeline where tuning the confidence threshold from 0.7 to 0.82 cut exception escalations by 34%. He covers 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.
Top comments (0)