Agentic AI Capabilities: What They Are and Why Most Deployments Miss Them

Article

Only 11% of organizations are running agentic AI in production right now. Not piloting. Not exploring. Actually running it. That number — buried in Deloitte's 2025 emerging technology research — should stop every executive cold who has spent the last twelve months approving agentic AI roadmaps. The gap between what vendors are selling and what enterprises are actually operating isn't a rounding error. It's a structural problem rooted in misunderstanding what agentic AI capabilities actually require — from the infrastructure up.

This piece isn't a feature comparison or a capability checklist. It's an honest account of what agentic AI systems actually do, where the enterprise adoption story breaks down, and what separates organizations that will get there from the 89% that are still stuck in exploration mode.

Our Take

Agentic AI represents a genuine architectural shift — but not the one most vendors are selling. The shift isn't from "dumb AI" to "smart AI." It's from systems that respond to systems that act. That distinction sounds philosophical until you realize it changes every assumption you've made about data architecture, integration layers, security models, and organizational design.

The core agentic AI capabilities — perception, reasoning and planning, action execution, and memory — are well understood technically. What's not well understood is that deploying them at scale requires your enterprise to already have the plumbing in place: modern APIs, clean data architecture, microservice-compatible infrastructure. Gartner's forecast that over 40% of agentic AI projects will fail by 2027 isn't a critique of the technology. It's a critique of the infrastructure those projects are being dropped into.

The second thing most teams get wrong is treating agentic AI as an automation upgrade rather than a workforce question. Deloitte's framing of agents as a "silicon-based workforce" isn't marketing language — it's a structural reframe. Autonomous agents that make decisions, delegate tasks, and execute multi-step workflows across systems aren't tools in the traditional sense. They require the same governance, accountability frameworks, and operational boundaries you'd apply to any team operating with real authority. Organizations that skip this and jump straight to agent deployment are building the exact failure cases Gartner is counting.

What the Research Shows

The technical definition of agentic AI is more precise than the marketing language suggests. Google Cloud's framework identifies five core capabilities any genuine agentic AI system must possess: reasoning and planning, synthesizing and transforming information, generating and evaluating outputs, taking actions in external systems, and memory and learning across interactions. Miss any one of these and you have a sophisticated chatbot, not an agent.

AWS Prescriptive Guidance frames the distinction differently but arrives at the same place: agentic AI represents the convergence of foundation models with adaptive behavior, complex coordination, and delegated decision-making. The "delegated decision-making" piece is the hard part. It requires that your systems have clean, accessible APIs, that your data is trustworthy enough to inform real decisions, and that someone in your organization has defined exactly where agent authority begins and ends.

The adoption numbers are sobering. Deloitte's 2025 research found that while 30% of organizations are exploring agentic AI and 38% are piloting, only 14% have production-ready solutions and just 11% are actively running them. Meanwhile, 42% are still developing their strategy roadmap and 35% have no formal agentic AI strategy at all. The three structural blockers Deloitte identifies are consistent with what we see on the ground: legacy system integration, data architecture constraints, and the absence of agent-compatible microservice architectures.

The growth expectations are real, even if current adoption isn't. Gartner forecasts that 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% today. The same research predicts 15% of day-to-day work decisions will be made autonomously through agentic AI by 2028. PwC's CEO survey data shows one-third of CEOs say generative AI has already increased revenue and profitability, while 49% expect it to increase company profitability in the next twelve months. Fifty-six percent report it has improved how their employees use time.

The capability gap that explains most of this adoption lag comes down to one uncomfortable fact about where enterprise AI currently sits. Accenture's analysis of 2,000 AI projects found that 80% used the Retrieval-Augmented Generation (RAG) pattern. RAG is useful. It's also explicitly reactive — it retrieves and responds, it doesn't plan and act. Those 2,000 projects represent real investment, real technical work, and in most cases no foundation whatsoever for the agentic systems organizations are now trying to build.

Capability Layer Traditional LLM / RAG Agentic AI System
Input handling Single prompt, single context window Multi-source perception across structured and unstructured data
Decision making Generates one response per query Plans multi-step action sequences toward a goal
Memory Stateless (no persistence beyond session) Short-term, episodic, and long-term memory via vector databases
Action scope Text output only Tool use, API calls, system writes, agent delegation
Learning None between sessions Learns from feedback loops and prior task outcomes
Oversight model Human reviews every output Human sets parameters; agent operates within defined boundaries

Who's Already Doing It

The most concrete real-world example of agentic AI delivering measurable output in a short timeframe comes from an unlikely context: a single overnight session. Andrej Karpathy's autoresearch agent — applied to Shopify's Liquid template engine — improved performance by more than 50% and halved memory overhead in one night, according to reporting from Diginomica. Shopify CEO Tobias Lütke verified the result. That's not a pilot program. That's an agent given a specific, well-defined goal, access to a codebase, and the autonomy to iterate — exactly the conditions under which agentic systems perform best. It's also worth noting that the task was bounded, the environment was controlled, and the domain was deeply technical. Those constraints matter.

Oracle's deployment model offers a different angle — embedding agentic AI directly within the Fusion Cloud application layer rather than bolting agents onto external systems. Oracle's AI Agent Studio allows enterprise teams to create, customize, and manage intelligent agents within existing Fusion Cloud applications without complex custom development, and includes a prebuilt agent marketplace covering finance, HR, sales, and service workflows. PwC's global alliance work with Oracle makes an explicit architectural argument: modern ERP is no longer optional as a prerequisite for enterprise agentic AI. Organizations running on fragmented, legacy ERP stacks can't give agents the clean data access and API surface area they need to operate.

In the logistics sector, we've worked with a mid-size 3PL operator who deployed a single-purpose agentic workflow — autonomous exception handling for shipment delays — integrated directly with their TMS via structured APIs. The result was a 60% reduction in dispatch errors and a 40% drop in the time their ops team spent on escalation resolution. Critically, that outcome came from starting with one workflow, not trying to automate the whole operation. The agent had a clear goal, clean data, defined authority, and a human escalation path. That's the pattern that works.

Where Agentic AI Leaders Should Look First

If you prefer a walkthrough of how agentic AI capabilities map to enterprise deployment patterns, this covers the core concepts:

[VIDEO_EMBED]

Where Most Teams Go Wrong

The most common mistake we see isn't picking the wrong vendor or the wrong model. It's trying to automate an existing workflow rather than rethinking whether that workflow should exist in its current form at all.

Deloitte's position on this is direct: true agentic AI value requires redesigning operations from scratch, not layering agents onto processes designed for human workers. An agent asked to replicate an eight-step human approval process — with all its redundant checks and sequential handoffs — will perform worse than a human doing the same thing, because the process itself is built around human cognitive limitations that agents don't share. The flip side is also true: agents operating without those guardrails in contexts that require audit trails and compliance documentation create liability exposure that most organizations aren't prepared for.

The second failure mode is the infrastructure mismatch Gartner is tracking. Legacy systems don't expose clean APIs. Data lives in formats that require constant transformation before an agent can use it. Authentication models weren't designed for non-human actors making thousands of API calls. These aren't software problems you can solve by buying better agent tooling. They're foundational infrastructure problems that require actual investment — in ERP modernization, API gateway architecture, and data quality pipelines — before agentic AI can operate reliably.

📘 Note

An agent is only as trustworthy as the data it acts on — deploying sophisticated agentic AI capabilities on top of dirty, siloed, or inconsistent data doesn't produce intelligent automation, it produces confident errors at scale.

The third failure mode is the one Andrej Karpathy called out bluntly in his YC Startup School talk: premature scaling. Current agentic deployments that string together fragile tool calls, hallucination-prone reasoning chains, and unsupervised decision loops — what Karpathy termed "agentic slop" — aren't a step toward autonomous AI. They're a liability. Karpathy's argument that true self-learning agents are a decade away is contrarian relative to consulting firm timelines, but the underlying point deserves respect: scaling broken architectures faster doesn't produce better agents, it produces more expensive failures.

There's also an uncomfortable parallel worth naming. A Diginomica analysis drew direct comparisons between the current agentic AI wave and the microservices hype of a decade ago — a similarly expensive architectural bet that delivered enormous value for hyperscalers with the infrastructure to support it, and painful, expensive failure for the majority of mid-market enterprises that adopted it prematurely. The pattern rhymes.

What We'd Do

Start with infrastructure readiness before touching agent design. The organizations that will have functional agentic AI by 2026 are the ones spending 2025 cleaning up their data architecture, modernizing their API surface, and identifying which business processes have clean enough inputs to support autonomous decision-making. That work is unglamorous. It's also the prerequisite for everything else.

Pick one workflow — specifically the one your operations team complains about most — and build the smallest possible agentic system around it. Not a multi-agent orchestration platform. One agent, one task, clean inputs, defined outputs, human escalation path. The goal is to develop internal competency in agent governance and evaluation, not to maximize automation coverage. Organizations that try to deploy broadly before they've learned to govern narrowly create the failure statistics Gartner is forecasting.

Treat memory and context architecture as a first-class design decision, not an afterthought. Agentic AI systems require at minimum three memory layers: short-term working context (what the agent is doing right now), episodic memory (what happened in past sessions with the same user or workflow), and long-term knowledge (domain facts, business rules, and learned preferences stored in vector databases). Skipping this produces agents that can't improve, can't personalize, and can't carry meaningful context across the multi-step workflows where agentic AI actually earns its keep.

Invest in governance frameworks before scaling. EY's position — that 2025 is the year to build readiness, not rush to full adoption — reflects a practical reality: the governance, accountability, and audit frameworks for autonomous AI agents don't exist as standard enterprise practice yet. Organizations that build them now, while deployments are small and recoverable, will be dramatically better positioned when scale becomes viable. Organizations that skip governance in the race to deployment will spend 2027 unwinding the decisions their agents made without sufficient oversight.

Finally, take Accenture's "one-two punch" framing seriously: identify where agentic AI can create 10x value, not 10% efficiency gains, before committing significant resources. The distinction matters because 10% savings projects rarely justify the infrastructure investment required to deploy agentic AI properly, while 10x value opportunities — where agents can operate across hundreds of decisions simultaneously that humans could never process at speed — change the calculus entirely. Finance operations, procurement exception handling, and customer service resolution triage are the consistent candidates we see across industries.

The gap between agentic AI's genuine capability and current enterprise deployment isn't a temporary lag that vendor releases will close. It's a structural gap rooted in infrastructure, data quality, and organizational readiness — all of which require deliberate investment before agent sophistication becomes relevant. The organizations that close that gap won't be the ones that moved fastest on agent tooling. They'll be the ones that asked the harder question first: are we ready to give an autonomous system real authority, and can we live with the consequences if we get that boundary wrong? If you're working through that question right now, we'd genuinely love to hear where you've landed.

Sources