AI Agents for Business: What They Are, How They Work and Real Use Cases

The word *agent* broke under overuse. In the same month you will see it used for a chatbot with a long script, an RPA bot filling in forms, and a system that genuinely decides on its own what to do with a case. All three cost different amounts, fail in different ways and are governed differently, so it is worth having the criteria to separate them before you sign anything.

Those four numbers describe the real state of the market: near universal interest, deployment at scale still marginal, and a marketing layer on top that does nothing to help you tell them apart. Read them precisely: the first two are self-reported by executives in a global survey; the third is published by Stanford's AI Index using data from that same global McKinsey survey (also self-reported, and the chapter itself asks you to read the figures as directional, not as a census), and it refers to use at scale, not to any experiment; and the Gartner one is the firm's estimate, not an auditable census. None of them is a Mexico figure.

An AI agent is a system in which a language model directs its own process: it takes an objective, decides which steps to take, uses tools to execute them, observes the result and corrects course until it finishes or until it asks for help. The cleanest technical distinction was published by Anthropic (a model provider, though the document is engineering rather than commercial): in a workflow, models and tools are orchestrated through predefined code paths; in an agent, the model dynamically directs its own process and tool usage, keeping control over how it accomplishes the task ¹. That is how Anthropic draws the line, not a definition the industry has settled.

McKinsey defines it from the business side with four combined attributes (autonomy, planning, memory and integration), and the combination is the whole point: take away any one of the four and you are left with something that already existed and that you probably already had ². Without connected tools, you have a chat. Without planning, you have a script. Without memory, you have a system that starts from zero on every interaction. Without bounded autonomy, you have a form with natural language on top.

The comparison matters because all three technologies coexist inside the same company and none of them fully replaces the others. This table is the summary I use in the first technical meeting:

On the inside, an agent is neither magic nor an exotic architecture. It is a loop with four moments, run as many times as needed until it meets the objective or hits a limit you defined. There is also a fifth exit, the one where it gives up and calls a human, which almost nobody designs.

1. 1

   Perceive: build the context

   The agent gathers what it needs to know: the ticket, the file, the customer history, the applicable policy. This is where the basic building block Anthropic calls the augmented LLM comes in: a model with retrieval, tools and memory ¹. If this layer is badly built, everything downstream inherits the error and no change of model compensates for it.

2. 2

   Plan: break the objective down

   The model turns *resolve this return* into a concrete sequence: verify the purchase, check the policy, calculate the amount, draft the reply. This is where an agent parts ways with an RPA bot: the sequence was not written in advance, it is produced against the case.

3. 3

   Act: use tools with explicit permission

   Every action goes through a declared tool: query the ERP, write to the CRM, issue the credit note. The golden rule is to separate reads from writes: reads can be free, every write needs a bounded scope, a cap on amount or volume, and an audit log.

4. 4

   Verify: check before calling it done

   Does the amount add up? Does the reply cite the right policy? Did the record actually get written? Without this step the system does not fail less: it fails silently, which is worse. Agents of this generation can get things wrong and end up trapped in loops, something Deloitte already flagged when it projected their adoption ¹⁰.

5. 5

   Escalate: know when to stop and call a human

   The step almost nobody designs. A mature agent has explicit surrender conditions: low confidence, an amount above a threshold, a customer flagged as sensitive, a third failed retry. With no exit to a human, autonomy stops being a design decision and becomes a bet.

It is worth separating what already has measured evidence from what is still projection. I will start with the measured part, even if it is less spectacular:

An honest counterweight drawn from the same body of evidence: the AI Index also includes the METR finding that experienced developers were 19% slower working with AI, a result that later did not replicate ⁴. I do not cite it to discourage you, but because anyone who presents this literature to you without mentioning the uncomfortable results is selling, not informing.

The figure that circulates most is Gartner's prediction that over 40% of agentic AI projects will be canceled by the end of 2027, due to escalating costs, unclear business value or inadequate risk controls ⁵. Two clarifications almost nobody makes when repeating it: it is a global prediction, not a measurement, and canceling is not failing technically. Plenty of projects die because the system works and still nobody can say which number it moved.

McKinsey offers the structural diagnosis. Close to 8 in 10 companies have deployed generative AI in some form, but roughly the same share reports no material impact on earnings (what the firm calls the *gen AI paradox*), and it locates the origin in an imbalance: horizontal use cases, such as enterprise-wide copilots and chatbots, scale fast but deliver diffuse gains that are hard to measure, while close to 90% of vertical use cases, the function-specific and genuinely transformative ones, remain stuck in pilot ².

On the most viral figure of them all, the 95% of organizations with no return whatsoever, some care is warranted: it comes from a preliminary report by researchers on the MIT Media Lab's NANDA project (not from MIT as an institution; the document itself clarifies that the views are the authors' own), not peer-reviewed, with a limited sample (52 interviews, 153 survey respondents and 300 public initiatives) and with backing data that was never published ¹². It measures the absence of reported return across the whole sample, not a technical failure rate: close to 80% of the companies never got as far as piloting custom tools, and among those that did, the success rate is around 25%. Add to that the fact that the four authors were developing or commercializing agentic AI solutions at the time of publication, a conflict the document does not declare.

The right question is not how much autonomy to give an agent, but how much to give each one. Gartner found that although 75% of the IT application leaders surveyed are already piloting or deploying some form of AI agent, only 15% are considering, piloting or deploying fully autonomous, goal-driven agents with no human oversight ⁶. The market is indeed adopting agents; what it avoids, with good reason, is letting go of the leash entirely.

The barriers reported by that survey explain the caution: only 19% have high or complete confidence in their vendor's ability to protect against hallucinations, 74% consider agents to be a new attack vector, and just 13% strongly agree that they have the right governance structures to manage them ⁶. It was fielded between May and June 2025 with 360 IT leaders at organizations of 250 or more employees in North America, Europe and Asia-Pacific: a global figure, and one about large companies, not about the Mexican SME.

Gartner also predicts that by 2027, 40% of enterprises will downgrade or decommission autonomous agents because of governance gaps detected only after production incidents, and its analyst Shiva Varma points to the root cause: agent governance gets treated as binary, either fully blocked or fully trusted. The recommendation is proportional governance across four levels (observe, advise, act with approval and act autonomously), assessing the level of autonomy and the scope of access independently ⁷.

This section exists because almost nobody writes it. There are four scenarios in which I explicitly recommend not building an agent:

• The process has fixed rules and zero ambiguity. An RPA bot or a direct integration costs less, fails less and audits better.
• The error has no undo: payments, payroll, legal or clinical decisions. There the agent can prepare and propose, but a human signs off on the write.
• The data the agent would need does not exist in queryable form, lives in someone's head, or sits in files nobody can export.
• Nobody on the business side committed to the metric that has to move. Without that, the project gets canceled even if the system works ⁵.

And a calibration note. In November 2024, Deloitte predicted that in 2025, 25% of the companies already using generative AI would launch agentic AI pilots or proofs of concept, and that the share would reach 50% in 2027 ¹⁰. The self-reported 2025 figures (62% of respondents experimenting, 23% scaling an agentic system, and no more than 10% scaling agents within an individual function ³) show the usual pattern: the experiment runs faster than anticipated and scaling runs much slower. The comparison is indicative, not exact: Deloitte's base is companies already using generative AI, and McKinsey's is all respondents to its global survey. That, and not the choice of model, is where the return gets decided.