Overview
Jess Grogan-Avignon and Jack Wang from Accenture deliver a brutally honest talk at the AI Engineer Conference about why most enterprise agentic projects fail before they even start — and it has nothing to do with the technology. They built an agentic application in 2 weeks; getting it to production took another 12 months. The bottleneck wasn't code quality — it was the enterprise itself: infrastructure teams, security reviews, AI gateway teams, data governance, and application teams all needing to align through human-speed processes. They present five enterprise tensions — Speed, Value, Delivery, Trust, and Moat — that predict the success or failure of any enterprise AI project, and offer concrete prescriptions for each.
1 The Enterprise Reality
Jess opens by painting the picture of their world: enormous enterprises — telecoms, utilities serving entire nations, government, healthcare, consumer products. At this scale, actions have consequences: a bad deployment can take down critical national infrastructure.
Over decades, these organizations built structures to manage that risk: control, process, repeatability, governance — layers and layers of it. And it worked. These companies saw massive success and growth. But always at human pace.
The tragedy isn't just wasted spend — it's falling behind in a world accelerating beyond what they can compute. Startups like Octopus, Klarna, and Shein look at enterprise timelines (6 months for a decision that takes an afternoon) and think it's insane — then go and redefine the games themselves.
2 Tension 1 — Speed: Human OS vs Machine Speed
Jack takes over with a stark observation: 18 months ago, you still needed to explain to executives why AI mattered. That battle is over. CEOs are now terrified of being left behind. But enterprise speed hasn't shifted — and it's not because AI can't write good code or engineers can't solve the context problem.
The bottleneck is the enterprise scaffolding itself — a human operating system designed for humans running at human speed. Data access, security reviews, deployment processes — most enterprises never needed to invest in engineering automation like a tech company would.
The 2 weeks → 12 months story
Jack shares their concrete experience: they built an agentic solution for a large corporation and integrated their centralized AI gateway. Every configuration change required manual review before tests could run. The application took 2 weeks to build. It took 12 months to get to production because the infrastructure team, security team, AI gateway team, data governance team, and application team all needed to align.
His analogy: imagine if Google Search required three teams to review results, a legal sign-off, and then a 2-week change freeze because it's quarter-end. That is how AI in enterprise delivery works today.
The code explosion
Making it worse: AI coding agents are turning everyone into a builder — PMs, designers, domain experts. The supply of deployable code is exploding:
But approval infrastructure and deployment infrastructure haven't changed because they were designed for human speed. The real tech debt isn't legacy code — it's years of underinvestment in engineering automation (CI/CD) that allows companies to move faster while maintaining control.
The pathway
Every human process needs to become adaptable, executable code — not another meeting, not a sign-off chain. Code. AI can help build this faster and cheaper, but it requires a fundamental mindset shift.
3 Tension 2 — Value: Your CFO Needs to Think Like a VC
Jess addresses the universal enterprise ritual: the business case to unlock internal funding. Business cases aren't wrong — they raise the right questions, create oversight, ensure someone has thought about ROI. But they assume three things are knowable up front:
- The scope and solution
- The expected value
- The cost and time to deliver
With AI, this is often backwards — you learn the solution and the business case by doing the work. And when execution cost for prototyping drops to near zero, it's no longer just about efficiency — it unlocks entirely new categories of things that weren't previously possible.
Evidence from AI Achievers
Real-world examples of emergent AI success:
- Cursor's user base of live coders didn't exist when they started building the product
- Claude Code wasn't planned out on a product roadmap months in advance
- Walmart built a social media trend scanner + generative designer to compete with Shein and Temu
- JP Morgan started building an internal productivity tool that they productized into an entirely new revenue stream
The VC mindset
Enterprise finance is wired for certainty — projects start life justifying committed benefits and predictable cost phasing. That framing kills projects before they begin because it asks "can we justify this specific thing?" instead of "what now becomes possible?"
The right question: what is the cost of NOT doing this?
A VC doesn't bet on one project and demand 3-year guaranteed payback. They back a portfolio, knowing most bets won't pay off, but looking for the ones that compound. Enterprise AI investment should work the same way.
4 Tension 3 — Delivery: Hypothesis-Driven, Not Milestone Programs
Jack addresses data scientists and ML engineers directly: "You've been doing something different from everyone else — hypothesize and experiment, statistical confidence." He argues most enterprises treated them like "the modern IT crowd" — brilliant, quietly right, and kindly ignored, kept in the basement while the upstairs did the "real work" through Jira boards at PI planning.
But agentic delivery is their world, not traditional software delivery's world:
- Models are non-deterministic — you can't scope it like a feature build
- Agent behavior is emergent — you can't milestone it like a fixed program
- Yet that's exactly what entire enterprises are trying to do
Where the energy goes
Jack observes that in the delivery trenches, enormous effort goes not to building things, but to bridging the gap between how agentic systems actually work and what stakeholders expect:
- Never-ending "utopian design up front"
- Constant conversations about guaranteed performance
- Endless status updates for decisions that never get made
The pathway
The organization needs to learn the data scientist's language — it's the only language that matters for agentic delivery:
- Reshape programs around one goal: building statistical confidence
- Small loops: build → evaluate → iterate → fast evidence
- Hire people comfortable with ambiguity who can articulate what they've learned, not just what they've delivered
- Translate statistical numbers into stakeholder confidence
5 Tension 4 — Trust: The Progressive Autonomy Ladder
Jess addresses the trust gap. No one cross-checks their Google results anymore. Most engineers in the room don't review every single code output from AI tools. AI trust is on the same trajectory — but it's not there yet for enterprises, and it's the AI engineer's job to bridge that gap.
The key insight: the completion of individual features is not the most valuable thing you ship. The trust in the outputs you build over time is. Trust means content accuracy, responsible use, privacy — everything that collectively allows end users to trust an AI system.
The trust account metaphor
Every agentic delivery is either a deposit or a withdrawal into a trust account with stakeholders, leadership, and end customers. What survives over time isn't a specific feature — it's the trust you've built as things evolve.
The exposure ladder — progressive autonomy
Many companies still treat agents like traditional automation: build, deploy, run. But agents aren't just turned on — their behavior is emergent and can't be fully tested up front. The solution is progressive autonomy:
- Shadow mode — agent runs alongside human processes but can't affect outcomes. Compare human decisions to agent recommendations. Use the delta as a signal to iterate
- Advisory mode — agent runs live but only recommends. Humans approve or reject. The accept/reject signal feeds back into improvement
- Controlled autonomy — agent can trigger actions in narrow, low-risk scenarios with clear limits and kill switches
- Wider autonomy — gradually extend scope based on achieving confidence targets in specific behaviors
The critical principle: each step is gated by evidence in outcomes — not by completion of activities in a project plan, not by pass/fail testing. It's entirely about confidence and trust in outcomes.
6 Tension 5 — Moat: Transactional Memory vs Living Memory
Jack poses the existential question: in a recursive world where AI codes AI, anything you ship can be cloned the minute it goes viral. So what is unique only to you?
Transactional memory (the floor)
Your existing enterprise knowledge — CRM, ERP, SOPs — got you to the table. But every competitor has their own version. It's a floor, not a fortress.
Living memory (the moat)
The real moat is what happens when your customer touches your product: edge cases, corrections, emotional intent, actual behavior at your specific scale in your specific context. Those signals belong to you.
The day you ship is not the finish line — it's when the race begins. How quickly you can compound and iterate, how fast you can turn a signal into value. It's a race against yourself to engineer your own competitive edge recursively and constantly.
The engineering principle
Every feature you ship should either:
- Generate a feedback signal, or
- Deliver on what a signal has already taught you
If it does neither, you're building something anyone can copy.
7 The Prescription — How to Apply This
Jess and Jack close with four concrete prescriptions:
- Start now. Deliver differently. Measure in terms of confidence, shape projects around hypotheses (not requirements or features), run delivery in small loops of experimentation, iteration, and evaluation
- Make finance a transformation partner, not a gatekeeper. Create a portfolio of AI bets across the organization rather than justifying each project in isolation. See value beyond the certainty of cost-out
- Make governance speed your CTO's top engineering problem. This is the ultimate technical debt to rectify
- For CEOs: your moat is not what you hold from yesterday. It's what you are learning and compounding every day. The winners won't be the earliest adopters — they'll be the ones that learn to learn
🎯 Key Takeaways
🔑 Key Takeaways
- 2 weeks to build, 12 months to deploy — the enterprise scaffolding (governance, security reviews, team alignment) is the bottleneck, not the technology
- Only 12% of companies reach "AI Achiever" status — the rest are stuck piloting, spending millions with minimal return
- 275M commits/week on GitHub in 2026 — approval infrastructure designed for human speed can't handle this throughput. Every human process needs to become executable code
- Your CFO should think like a VC — back a portfolio of AI bets, not individual projects with guaranteed ROI. The value is beyond certainty, in power-law compounding
- You learn the business case by doing the work — with near-zero prototyping costs, the right question is "what becomes possible?" not "can we justify this?"
- Hypothesis-driven delivery replaces milestone programs — agentic systems are non-deterministic and emergent. Scope them like experiments, not feature builds
- Progressive autonomy builds trust at speed — shadow mode → advisory mode → controlled autonomy → wider autonomy, each step gated by outcome evidence
- Trust is the product, not features — every delivery is a deposit or withdrawal from a trust account with stakeholders and customers
- Your data is a floor, not a fortress — CRM/ERP/SOPs are transactional memory that every competitor has. Your real moat is living memory: customer signals, edge cases, behavioral data at your specific scale
- Feedback is the only moat — every feature should either generate a signal or deliver on what a signal taught you. If it does neither, anyone can clone it