Most agentic AI use cases in circulation are still pilots. A smaller set runs at real scale today, and these four have public evidence behind them:
- Coding agents that read and edit a repository from inside the editor.
- Computer-use agents that drive a desktop through mouse and keyboard input.
- Document-heavy operations work, with finance as the clearest example.
- Agent-initiated payments, now with card-network infrastructure underneath them.
An agent, meaning a system that picks its own next step and calls tools without being told which one, earns its place when a task repeats often and a wrong answer is caught cheaply. The second condition is where most projects quietly fall over.
Google's 2025 DORA report, built on survey responses from nearly 5,000 technology professionals, found 90% of respondents using AI at work while 30% reported little or no trust in the code it produces. Ninety percent adoption alongside thirty percent distrust is the working relationship most engineers already have with their build system.
AI agent vs agentic AI: what counts as a use case
The two terms get used interchangeably and the distinction is small. An AI agent is one system pursuing a goal with tools. Agentic AI is the umbrella label for the whole design approach, including setups where several agents hand work to each other.
The useful question sits underneath both labels. Ask what the system is allowed to do without checking with anyone. A model that drafts an email is an assistant. A model that sends it is an agent, and the interesting engineering lives in the gap between those two sentences.
That gap is what turns a demo into a use case. Every category below is a question about how much autonomy a task can absorb before the cost of being wrong outruns the value of the speed. Our piece on which AI agents are worth building for a business works through the same trade one agent at a time.
Vendors rarely frame it this way, because "autonomous" sells better than "autonomous within limits you will spend two quarters tuning."
Software engineering and the text editor AI agent
The clearest agentic AI use case is the one built by the people building agents. A text editor AI agent lives in the repository, reading files and running the test suite on its own. It keeps editing until something passes. No other category has this much daily usage behind it.
It works because software happens to be the ideal shape for an agent. The environment is text the model can read directly, and the feedback loop is a test runner that grades faster than any reviewer. A wrong answer shows up as a red build within minutes.
The same DORA research found a positive relationship between AI adoption and software delivery throughput, alongside a negative relationship with delivery stability. More changes ship, and more of them break. Teams with strong automated testing absorb that; teams without it find their weak spot at speed. The report's own summary is that AI amplifies what a team already is, and amplifiers are famously indifferent to what you feed them.
The career question underneath all this deserves more than a shrug, and we took it seriously in whether software engineers will be replaced by AI. The short version is that review became the scarce skill.
When an AI agent controls mouse and keyboard input
The second category widens the first. The agent takes a screenshot and works out where things are on screen. Then it moves the pointer and types. Anthropic's computer use tool is the documented version of this, and the documentation is unusually honest about what it costs.
Several limitations are listed there, and each one shapes what the use case can be:
- Latency, which rules out anything a person is sitting there waiting for.
- Coordinate accuracy, since the model can hallucinate the position it is clicking.
- Tool selection, which degrades with niche applications or with several applications open at once.
- Spreadsheet work, where selecting individual cells often takes multiple attempts.
The security guidance is stricter, and it deserves straight delivery. Anthropic recommends running the agent inside a dedicated virtual machine with minimal privileges and keeping credentials away from it, among other precautions. The one to insist on is human confirmation for any action with real-world consequences. The reason is prompt injection: instructions sitting inside a webpage or an image can override yours, and a model that reads the screen reads everything on it.
So the honest version of this use case is narrow. Background work inside a sandbox, or driving a legacy system that never got an API. Anything touching a live account belongs behind a confirmation step.
AI agents in finance and the back office
AI agents in finance take on work that is high in volume and bound by rules. Matching an invoice against a purchase order, or pulling figures out of a supplier PDF that has been reformatted three times since anyone last looked at it. A model reads the messy document and the structured ledger with the same patience.
Finance is also where governance stops being a slide and becomes a control. Regulated firms already run model risk frameworks, and an agent that classifies a transaction is a model making a decision that has to be explainable afterwards. Log what the agent saw and which tools it called, because "the agent decided" will not survive an audit.
Run it in suggest-only mode for longer than feels necessary. The agent proposes and a person approves. Every approval becomes evidence about where the thing can be trusted. Money moving on an agent's decision alone is a bar most organisations should not clear yet.
Agentic commerce and the card networks
Agentic commerce is the newest category with real infrastructure behind it. The premise is that an agent buys something for you, which immediately raises the question the card networks had to answer: how does a merchant tell an authorised agent from a fraud script?
Visa's answer is Intelligent Commerce Connect, announced in April 2026 as a single integration for merchants and agent builders, supporting four agent payment protocols and running with named pilot partners through the year. Merchant-specific tokens stand in for the card number, with permissions scoped to what the user actually allowed. Mastercard's Agent Pay covers similar ground with agentic tokens and spending limits attached to the agent's identity.
None of this is a finished rail yet. The signal worth reading is that the plumbing is being built at the network layer, which is where trust in payments has always lived.
The consumer version is a price watcher that buys when a threshold is hit. Worth stating plainly: an agent holding a payment credential is a standing authorisation, so the spending limit is the security control. Set it before the agent has anything to spend.
What agentic AI companies get wrong before production
Ask which agentic AI companies are worth watching and you get a vendor list with a shelf life of about six weeks. The better question is what separates the deployments that survive from the ones that stall, because the pattern repeats across every category above.
Three failures cover most of it:
- No evaluation harness. The team ships on impressions, then cannot tell whether last week's prompt change helped or hurt.
- Autonomy granted by default. The agent gets write access on day one because suggest-only felt like a downgrade.
- No owner for the mistakes. When an agent is wrong, a person has to be accountable, and "the model" cannot be asked to explain itself in a meeting.
Every one of these is a management problem wearing an engineering costume.
The architecture half of the answer, meaning tool design and reasoning loops, is covered properly in the engineering guide to agentic systems. Verification is the other half, and it is the same shift we described in how AI agents will change research. Producing output got cheap. Checking it did not.
If you are choosing where to start, pick the use case where you already have a checker. A test suite, or a reconciliation report that runs every month anyway. Agents pay back fastest where the answer can be graded without convening anyone, and they fail slowest where nobody notices for a quarter.
Then grant autonomy the way you would grant database permissions, reluctantly and with a way to take it back. Where to draw that boundary, and who signs off on moving it, is the subject of the business guide to integrating agents.