The pitch deck on enterprise AI agents in 2026 reads like the pitch deck on RPA in 2018, the pitch deck on chatbots in 2017, and the pitch deck on enterprise search in 2012. The shape is familiar: a demo that handles a curated path beautifully, a slide titled “and this generalizes,” and a roadmap that quietly assumes the hard parts will be solved by the next model. We’ve now run agent pilots inside enough mid-market and enterprise data orgs to triage the hype with some confidence. The headline: agents work, but only in a narrower band than the marketing suggests, and the band is defined by feedback signal, not by industry vertical or model size.

The pattern that actually works

Agents earn their keep when three conditions hold at once. The task lives inside a single system or a small, stable set of systems. Success is observable in machine-readable form within seconds or minutes of the action. And the task repeats often enough that an automated retry-and-correct loop has time to converge before a human would have done the work themselves.

When all three hold, you get a tight feedback loop: the agent acts, the system tells it whether the action worked, and the agent corrects on the next iteration of the same workflow. That loop is the entire game. Nothing else about the agent — model size, prompting, tool design, memory architecture — matters more than whether that loop is closed.

Where agents are real

Ticket triage in a known taxonomy. Customer-support and IT-service tickets land in a queue with a fixed schema, route to one of a finite set of teams, and have a clearly observable outcome (was it reopened, did the SLA hold, did the customer come back). Agents read the ticket, classify against the taxonomy, draft a first response, and escalate when their own confidence is low. The feedback signal — reopen rate, time-to-resolution, customer follow-up — is direct and arrives within days. We see 30–50% deflection on the well-defined classes after a quarter of tuning, and the failure modes are loud and recoverable.

Data quality and pipeline self-healing. A pipeline fails. An agent reads the error, checks the lineage, identifies the upstream change, drafts a patch (schema cast, column rename, freshness threshold adjustment), opens a PR, and waits for the CI suite to verify. The CI run is the feedback signal. The agent doesn’t need to be right on the first try — it needs to be right within the budget the orchestrator allows. dbt projects with strong test coverage and SQLMesh projects with virtual environments are particularly well-suited because the verification surface is rich.

Code-review augmentation on a defined ruleset. Not “review this PR for quality” — that’s open-ended and the agent will confabulate. Rather “check this PR against these twelve rules” — secret patterns, dependency pinning, frontmatter schema conformance, MDX allowlist, license headers, banned imports. Each rule has a clear pass/fail check. The agent runs the checks, posts findings, and the human merges or rejects. The agent’s job is mechanical, the feedback is immediate, and the value is the time the senior engineer doesn’t spend on rote inspection.

Sales-ops list enrichment with a verifier. Given a CRM record, look up the company in three data sources, reconcile, and write the canonical fields. The verifier is a deterministic matching rule plus a sample audit. Agents do this well because each record is independent, the schema is fixed, and the audit closes the loop on accuracy.

Narrow research with a citable corpus. Given a closed corpus (legal docs, RFPs, internal wiki, a specific documentation set) and a question whose answer must be grounded in that corpus, agents retrieve, synthesize, and cite. The citation is the feedback signal — a human can spot-check whether the cited passage actually supports the claim. Open-web research breaks this because the corpus is unbounded and the citations can be hallucinated or outdated.

Where agents don’t work yet

Open-ended novel research. “Investigate why churn went up last quarter and recommend a strategy.” The space of valid hypotheses is large, the feedback signal arrives in months, and the agent has no way to know whether its conclusion is correct before committing to it. The agent will produce a plausible-sounding answer that is structurally indistinguishable from a correct one, and the cost of acting on the wrong one is real. Humans do this work because the judgment about which threads are worth pulling is the work.

Cross-system orchestration with messy state. A workflow that touches CRM, ERP, billing, the data warehouse, a ticketing system, and a Slack channel, where each system has its own latency, eventual-consistency guarantees, and quiet failure modes. The agent will get partway through, hit a stale read or a permission error, and either give up or — worse — retry in a way that creates duplicate writes. The fix isn’t a smarter agent; it’s an orchestration layer with idempotency keys, compensating actions, and a reconciliation job. That layer is the actual product. Once you build it, the “agent” part is a thin wrapper.

Anything where success requires reading a human’s mind. “Make the dashboard look professional.” “Pick the right metric for this exec review.” “Decide which of these five priorities matters most this quarter.” The model has no access to the political, historical, and personal context that determines the right answer. It will produce an answer; that answer will be confidently wrong in ways that take a human ten minutes to diagnose and an hour to fix. Net negative.

Long-horizon agentic work without checkpoints. A six-step plan where step three depends on the output of step two and step five depends on a judgment call from step four. By step five, error has compounded, the agent has lost the thread, and the work has to be redone. The fix is to make each step its own short-loop agent with its own verifier — at which point you’ve rebuilt a workflow engine and the “agent” framing is doing no work.

The practical filter

Before scoping an agent project, write down the success signal, the latency to that signal, and the verifier. If the signal is “a human eventually decides whether they like it,” the project is not an agent project, and dressing it up as one will burn budget. If the signal is a deterministic check that fires within minutes, the project is a candidate, and the next question is whether you have the orchestration plumbing to make the loop reliable. Build the plumbing first. The agent is the easy part.