What's Real, What's Hype, What's Risky
Narrow supervised agents, agent washing, and new risks
- Calibrate expectations for what agents reliably do today versus the autonomous-digital-employee hype
- Name the hard limits that gate agent scaling — no on-the-job learning, compounding error, and data/integration readiness
- Recognize the new security surface that appears the moment an agent can act: prompt injection, goal hijacking, tool-authorization abuse, and cascading multi-agent failures
- Spot "agent washing" using the three real-agent capabilities, and read market signals like Gartner's cancellation forecast as a maturity check, not a reason to abstain
- Apply the delegation test to decide which decisions to automate and which to keep human
- Ask the right governance questions before greenlighting any agent that takes actions in production
Agentic AI in 2025-2026 is genuinely useful for narrow, supervised, well-structured, lower-stakes tasks — not the autonomous "digital employee" the marketing implies. This lesson gives you the leadership lens to separate real agents from "agent washing," understand the hard limits and the new security surface that come with software that *acts*, and apply a simple delegation test for deciding what to safely automate.
- 1The reality line: narrow, supervised, well-structured
- 2The hard limits: why agents stay narrow
- 3The new security surface: when software can act
- 4Cutting through hype: "agent washing" and the market signals
- 5The delegation test: deciding what to automate
- 6The right questions before you greenlight an agent
The reality line: narrow, supervised, well-structured
The single most valuable thing a leader can do with agentic AI right now is set the expectation correctly — because the gap between the demo and the deployment is where budgets disappear.
Here is the durable, research-grounded reality for 2025-2026: agents are reliable for narrow, supervised, well-structured, lower-stakes tasks — not autonomous "set-and-forget" digital employees. Anthropic's own guidance from running agents in production is blunt: the systems that work today "tend to be simple and human-supervised" — narrow in scope, with permissions configured per action (Anthropic, Trustworthy Agents, 2025).
That is not a disappointment; it is a targeting instruction. The wins are real where the task is bounded and repeatable:
| Reliable now (narrow, supervised) | Not reliable yet (broad, autonomous) |
|---|---|
| Service-desk / IT ticket triage and routing | Running a function end-to-end with no human |
| First-draft research and document summarization | Novel strategy or high-stakes judgment calls |
| Low-risk, rule-bound approvals and anomaly flagging | Unsupervised actions in legal / financial / safety contexts |
| Coding assist (write, test, ship under review) | "Hire it like an employee and walk away" |
The two most common enterprise agent uses today are exactly this shape: IT/service-desk agents and knowledge "deep research" agents (McKinsey, State of AI, 2025). High-volume, well-structured, supervised. The hype runs ahead of the reliability — and the leader's job is to aim spending at the part that works.
Key insight
The reframe
"Reliable for narrow, supervised tasks" is not a ceiling on ambition — it is a map of where the value is today. Aim pilots at high-volume, well-structured, lower-stakes processes and you land in the part of the frontier that actually pays. Aim at "autonomous digital employee" and you fund a science project.
Watch out
Where leaders get it wrong
Treating a polished vendor demo as production-ready. Demos are run on curated inputs inside the frontier; production sends messy, adversarial, edge-case traffic. The right question after any demo is: "Show me the failure cases and what the human does when it's wrong."
The hard limits: why agents stay narrow
Agents stay narrow for structural reasons, not because vendors haven't tried hard enough. Three limits gate how far you can scale, and a leader who can name them will not be surprised by a stalled pilot.
1. They don't learn on the job by default. This is the most counter-intuitive limit for executives who imagine an agent that "gets better the more it works." MIT's NANDA study found most GenAI systems "do not retain feedback, adapt to context, or improve over time" — a primary reason pilots stall. NANDA labeled the broader failure the learning gap, and found roughly 95% of enterprise GenAI pilots delivered no measurable P&L return — with the root cause being workflow and integration, not model quality (MIT NANDA, The GenAI Divide / State of AI in Business 2025).
2. Error compounds over long action chains. Every step an agent takes has some error rate. Chain ten steps together and the chance the whole sequence is correct collapses, even if each individual step is usually right. This is the mathematical reason production scope stays short and supervised — and why "give it a goal and let it run for an hour unattended" is not yet a safe pattern for anything load-bearing.
3. Data and integration readiness gate everything. Agents act through your systems and data. If your data is siloed, ungoverned, or your systems are legacy, the agent has nothing reliable to act on. Eight in ten companies cite data limitations as the roadblock to scaling agents (McKinsey, 2025), and legacy-system incompatibility is a leading reason agent projects fail (Gartner). As the saying goes: an agent cannot query what it cannot find.
| Hard limit | What it means in practice | Leadership implication |
|---|---|---|
| No on-the-job learning | It won't quietly improve; performance is roughly what you ship | Budget for monitoring and updates; don't assume a learning curve |
| Compounding error | Long autonomous chains fail more than the parts suggest | Keep scope short; insert human checkpoints |
| Data/integration readiness | ~80% blocked by data limits | Fix data and integration before scaling agents |
Example
The 95% that returned nothing
MIT NANDA's GenAI Divide (July 2025) studied 300+ initiatives and found ~95% of enterprise GenAI pilots produced no measurable P&L return — only ~5% reached rapid value. The decisive variable was not the model; it was whether the organization closed the learning/integration gap. The lesson: the agent is the easy 20%; data, workflow, and integration are the hard 80%.
Tip
The leadership move
Before approving an agent pilot, ask one question: "Is the data this agent needs clean, governed, and reachable?" If the honest answer is no, you are funding a data project disguised as an AI project — sequence the data work first.
The new security surface: when software can act
Here is the reframe that should change how you govern: the moment an agent can take actions — browse, email, run code, move money, call APIs — its mistakes stop being embarrassing and start being material. A chatbot that hallucinates produces a bad sentence. An agent that is manipulated can exfiltrate data or execute an unauthorized transaction. The autonomy and tool-access that create the value also create the blast radius.
Four new risks every leader should be able to name (OWASP Top 10 for Agentic Applications, 2026):
- Prompt injection — hidden malicious instructions buried in a webpage, email, document, or database the agent reads, which hijack its behavior. Harmless for a chatbot; for an agent with tool access it can mean data exfiltration or unauthorized actions.
- Goal hijacking — the agent gets redirected from its assigned objective toward an attacker's objective mid-task.
- Tool-authorization abuse — the agent has more permissions than the task needs, so a single compromise reaches systems it never should have touched.
- Cascading multi-agent failures — agents that call other agents can propagate and amplify a single error or compromise across a chain.
The governing principle is simple: the more autonomy and tool-access an agent has, the larger its blast radius — so controls must scale with autonomy. The mitigations are conceptual, not technical, and a board can ask for every one of them:
| Control (askable by a leader) | What it limits |
|---|---|
| Least-privilege tool access | Smallest blast radius — the agent can only touch what the task requires |
| Sandboxing | Contains the agent so a failure can't spread to production systems |
| Input validation | Reduces the prompt-injection attack surface |
| Human approval for high-impact actions | A person signs off before money moves or data leaves |
| Halt / rollback | You can stop a misbehaving agent and undo its actions |
Key insight
The reframe
Traditional cybersecurity protects data at rest and in transit. Agentic security must protect data and systems in the moment of action. You are no longer only guarding the vault — you are supervising a worker who has the keys.
Watch out
Where leaders get it wrong
Underestimating agentic risk because the underlying model "seemed fine in testing." The danger isn't the model misbehaving on its own — it's an attacker turning the model's helpfulness against you via injected instructions, amplified by whatever tool permissions you granted. Scope permissions tightly before you scale autonomy, not after an incident.
Cutting through hype: "agent washing" and the market signals
As budgets shift to agents, vendors are relabeling chatbots, RPA scripts, and assistants as "agents." This is agent washing, and a leader needs a simple test to see through it.
The three-capability test (Gartner). A genuine agent has all three; a relabeled chatbot has none or one:
- Autonomous reasoning — it decomposes a goal into steps and adapts when a step fails (not a fixed script).
- Tool orchestration — it calls APIs, databases, and other systems to act, not just to talk.
- Persistent context — it remembers the ongoing project and organizational knowledge across steps.
Now the market signals — and the discipline is to read these as maturity-check numbers, not reasons to abstain. All are time-stamped findings; verify the live figure before quoting it:
| Signal (source, year) | What it says | How to read it |
|---|---|---|
| Gartner: >40% of agentic AI projects canceled by end of 2027 | Driven by cost, unclear value, and weak risk controls | Not "agents fail" — "undisciplined agent projects fail." Avoid the named causes and you're in the other 60%. |
| Gartner: only ~130 of thousands of self-styled "agentic" vendors are genuine | Most "agentic" branding is washing | Run the three-capability test on every vendor pitch. |
| MIT NANDA: ~95% of GenAI pilots returned no P&L (2025) | The learning/integration gap, not the model | Invest in workflow and data, not just the tool. |
These numbers are deliberately uncomfortable, but the strategic read is constructive: the failures cluster around cost overruns, unclear value, weak risk controls, and bolting agents onto unchanged workflows. Each is an executive-controllable variable. The leaders in the surviving cohort scope tightly, anchor to a KPI, govern deliberately, and redesign the workflow around the agent.
Example
The both-sides case: Klarna
Klarna's AI assistant handled ~2/3 of support chats in its first month (~2.3M conversations), cut resolution from ~11 minutes to under 2, and was pitched as ~700 FTE-equivalent with ~$40M projected 2024 profit uplift (Klarna, 2024). Then it partly reversed: by mid-2025 Klarna rehired humans after CSAT declined. CEO Siemiatkowski: "We focused too much on efficiency and cost... lower quality... not sustainable." The lesson isn't "agents don't work" — it's that volume metrics masked a quality collapse on nuanced, empathetic work (Entrepreneur, 2025).
Tip
The leadership move
Treat Gartner's ">40% canceled" as a checklist of failure modes to design out, not a verdict on the technology. Before greenlighting: Is the value defined and measurable? Are the risk controls in place? Are we redesigning the workflow or just bolting an agent on? Three yeses puts you in the surviving cohort.
The delegation test: deciding what to automate
So how do you actually decide what to hand to an agent? The governing principle is automation for execution, humans for judgment — and the practical screen is the delegation test.
Delegate a decision to an agent only when all three are true:
- The data is clear — the agent has reliable, governed, reachable information to act on.
- The rules are defined — there is an explicit, agreed policy for what "right" looks like.
- The cost of waiting for a human exceeds the cost of a wrong autonomous action — speed genuinely outweighs the downside of an occasional error.
If any one fails, keep a human in (or on) the loop. The third condition is the one leaders skip: it forces you to honestly price the downside of being wrong. Reordering a stationery supply when stock runs low? A wrong action is cheap and waiting is costly — delegate. Approving a mortgage, terminating an account, or releasing a public statement? A wrong action is expensive or irreversible — keep it human.
This maps cleanly onto the autonomy spectrum:
| Delegation-test result | Autonomy posture | Human role |
|---|---|---|
| All three true, low stakes | Agent acts within policy | On the loop — escalation point |
| Mixed / medium stakes | Agent proposes, human approves | In the loop on high-impact steps |
| Any condition fails, or high stakes | Human decides; AI assists | Human makes the call |
The delegation test is also a governance instrument. It produces a defensible, written rationale for why a given decision was automated — exactly what a regulator, an auditor, or your own board will eventually ask for.
Key insight
The reframe
The strategic question is never "can we automate this?" — increasingly the answer is yes. It is "should we, given the cost of being wrong?" The delegation test moves the decision from technical capability to business judgment, which is where it belongs.
Tip
The leadership move
Run every proposed agent use case through the three-part test out loud in the room. Use cases that pass become your near-term pilots; use cases that fail on "cost of wrong action" become your human-in-the-loop designs. The test turns a vague "let's do agents" into a prioritized, governed portfolio.
The right questions before you greenlight an agent
You don't need to operate the controls; you need to be able to ask whether they exist. The autonomy that makes agents valuable is precisely what makes them a board-level governance topic — and the signal is sobering: only 28% of organizations say the CEO directly owns AI governance, and just 17% say the board does (McKinsey, State of AI, 2025), even as 51% reported at least one negative AI incident in the prior year. Diffuse accountability is the clearest place leaders get this wrong.
The durable governance vocabulary is the NIST AI Risk Management Framework — four functions: Govern (cross-cutting culture and accountability), Map (the system's purpose and impacts), Measure (assess and monitor risk), Manage (act on it). For agents specifically, oversight extends to autonomy level, tool permissions, and halt/rollback. Treat these as the questions to put to any team proposing a production agent:
| Domain | The question to ask |
|---|---|
| Ownership | Who is the named owner accountable for this agent's behavior, safety, and compliance? |
| Delegation | Does this decision pass the three-part delegation test, and is that rationale written down? |
| Permissions | Does the agent have least-privilege access, or more than the task needs? |
| Human control | Where is a human in/on the loop for high-impact actions, and can we halt and roll back? |
| Security | How are we defending against prompt injection and goal hijacking on its tool surface? |
| Measurement | Are we tracking quality (CSAT/error rate), not just volume — the Klarna lesson? |
| Inventory | Is this agent on our AI-system inventory? (You cannot govern what you can't see.) |
This is not bureaucracy that slows you down. High performers govern more deliberately and ship faster, because trust is engineered in rather than bolted on after an incident. Governance is a value-enabler, not a brake.
Watch out
Where leaders get it wrong
Assuming "someone owns AI risk." With only 17-28% placing accountability clearly with the board or CEO, the default state is diffuse ownership — which means no one halts a misbehaving agent until after it has done damage. Name a single accountable executive per production agent before it goes live.
Tip
The leadership move
Adopt the NIST AI RMF vocabulary (Govern / Map / Measure / Manage) as your common language and require a one-page risk note for every production agent. It forces the right questions to be answered before deployment and gives you a defensible record if a regulator ever asks.
Try it: Agent Reality & Risk Register: triage three use cases
A strategic exercise — no coding. Pick three candidate agent use cases from your own organization (e.g., service-desk triage, invoice reconciliation, autonomous refund approvals, a research-drafting agent, a customer-facing support agent). For each, produce a one-page decision note:
1) Reality check. Is this task narrow, supervised, well-structured, and lower-stakes — or are you reaching for an 'autonomous digital employee'? Note which side of the reality line it sits on and why.
2) Hard-limits screen. Rate each on the three gates: Is the data clear, governed, and reachable? Does the task involve a long autonomous chain where error compounds? Is integration with your systems realistic today? Flag any red.
3) Delegation test. Score each use case on the three conditions — data clear / rules defined / cost-of-waiting > cost-of-wrong-action. Decide the autonomy posture: agent acts within policy, agent proposes + human approves, or human decides, AI assists.
4) Security & agent-washing. For any case you'd automate, list the tool permissions it needs and apply least privilege; name the high-impact actions requiring human approval; confirm you can halt and roll back. If a vendor is involved, run the three-capability test (autonomous reasoning, tool orchestration, persistent context) and note whether it's a genuine agent or agent washing.
5) Governance one-pager. For your single highest-priority case, draft the risk note you'd bring to the board: named owner, delegation rationale, permissions, human-in/on-the-loop design, prompt-injection posture, the quality metric (not just volume) you'll track, and its place on the AI-system inventory.
Deliverable: a ranked shortlist — which use case you'd pilot first, which becomes a human-in-the-loop design, and which you'd defer until data or integration matures — plus the one-page board risk note. This is the exact artifact that separates the surviving 60% from the canceled 40%.
Key takeaways
- 1In 2025-2026, agents are reliable for narrow, supervised, well-structured, lower-stakes tasks (IT triage, research drafting, coding assist) — not autonomous, set-and-forget digital employees. Aim pilots at where the value actually is.
- 2Three hard limits keep agents narrow: they don't learn on the job by default, error compounds over long action chains, and data/integration readiness gates scaling (~80% of firms cite data limits — McKinsey 2025).
- 3The moment an agent can act, it opens a new security surface — prompt injection, goal hijacking, tool-authorization abuse, and cascading multi-agent failures — and the blast radius grows with autonomy and tool access (OWASP 2026).
- 4Cut through "agent washing" with the three-capability test (autonomous reasoning, tool orchestration, persistent context); Gartner says only ~130 of thousands of vendors are genuine and >40% of agentic projects will be canceled by end of 2027 — read that as a checklist of failure modes to design out.
- 5Use the delegation test — automate a decision only when data is clear, rules are defined, and the cost of waiting exceeds the cost of a wrong autonomous action — to turn "let's do agents" into a governed, prioritized portfolio.
- 6Agent autonomy makes governance a board-level issue: name an accountable owner, enforce least-privilege and human approval for high-impact actions, ensure halt/rollback, and track quality not just volume (the Klarna lesson).
Quiz
Lock in what you learned
Check your understanding
0 / 4 answered
1.A vendor pitches an 'autonomous AI digital employee' that will run your accounts-payable function end-to-end with no human involvement. Based on the 2025-2026 reality of agentic AI, what is the most grounded executive response?
2.Which set best captures the NEW security surface that appears specifically because an agent can take actions (browse, email, run code, call APIs), rather than just answer questions?
3.Gartner forecasts that over 40% of agentic AI projects will be canceled by the end of 2027 (citing cost, unclear value, and weak risk controls), and that only ~130 of thousands of self-styled 'agentic' vendors are genuine. How should a leader interpret these figures?
4.Your team wants to let an agent autonomously approve or deny customer refunds up to $5,000. Applying the delegation test, which condition is the one most likely to be overlooked — and is the deciding factor here?
Go deeper
Hand-picked sources to keep learning
Why production agents today 'tend to be simple and human-supervised' — the source for the narrow, supervised reality line.
Live source for the cancellation forecast, the ~130 genuine-vendors figure, and the three real-agent capabilities. Verify current numbers before quoting.
The ~95%-of-pilots-return-nothing finding and the 'learning gap' — the structural reason agents don't improve on the job.
The agentic security surface: prompt injection, goal hijacking, tool-auth abuse, and the askable mitigations (least-privilege, sandboxing, human approval).
The canonical cautionary tale: volume metrics masked a quality collapse on nuanced, empathetic work — track quality, not just volume.
The durable governance vocabulary for asking the right oversight questions before greenlighting a production agent.