AI Agents Don’t Improve The Business Until They Can Act In It
Massimo Pezzini, former distinguished VP analyst at Gartner, says AI agents start changing the business once they can act in the systems they run on, and explains how business skills make that execution secure, reliable, and affordable.

“AI agents deliver limited value if they can only give you answers, but they are invaluable when they work alongside your enterprise systems.”
It is increasingly evident, almost common sense, that the value of AI agents lies not only in answering complex business questions, but also in acting on these answers. Consider an AI agent able to:
- Sense a business event (e.g., “customer XYZ has requested a $20,000 loan”);
- Evaluate the applicable business rules (e.g., “the bank grants a $20,000 loan to clients with a FICO credit score of ‘good’ or higher”);
- Decide on the best course of action (e.g., “customer XYZ’s FICO credit score is ‘very good’, so the bank can grant the loan”);
- Perform the actions that respond to the business event (e.g., “kick off the loan origination process for client XYZ”).
This AI agent is far more valuable, in both efficiency and business effectiveness, than one that merely answers a human decision-maker's question about how to move the process forward (e.g., a bank clerk asking, “What is the minimum FICO credit score for a $20,000 loan?”).
Agents like this one must be integrated into the organization’s enterprise systems to make decisions and act accordingly. In this (admittedly simplistic) banking example, the AI agent must connect to a credit bureau to retrieve the customer’s FICO credit score, and to the bank’s Loan Origination System to start the loan process.
That leaves CIOs with a practical question: How should they integrate AI agents with enterprise systems, and which architectural patterns, technologies, and best practices should they use? The systems in question range from ERP, CRM, SCM, and HCM to MES, student information systems, and core banking and insurance platforms.
What is a business skill?
The actions an AI agent can perform are typically encapsulated in an architectural construct we call a “business skill”: packaged know-how about a well-defined subject. An AI agent is typically equipped with multiple skills, which it orchestrates in response to business events according to the course of action it has decided on (see Figure 1).

In practice, a business skill is a self-contained piece of deterministic business logic implementing a meaningful business capability (for example, “Tax Calculation,” “Invoice Validation Against PO,” and “Loan Origination”).
Business skills provide a well-defined interface (typically API- or event-based) and expose a clear, precise description that the AI agent can use to:
- Discover all the skills available to it
- Understand how to execute these skills and the functionality they provide
MCP is the de facto business skills enabling standard
Vendors implement business skills in different ways, but the Model Context Protocol (MCP) has emerged as the de facto standard for enabling AI agents to engage with skills. At its core, MCP provides:
- A mechanism for AI agents to discover each business skill’s description, input and output schemas, and other relevant metadata.
- A JSON-RPC/HTTP-based transport layer for AI agents to call the functionality the skills provide.
In MCP jargon, an MCP-enabled business skill is called an “MCP server” and its externally accessible functions are called “tools.” An MCP server is a black box: software that implements a well-defined set of tools, which the agent can engage only via MCP. That’s why AI agents are often called “MCP clients.”
MCP is sometimes criticized for its complexity and limitations, which require organizations to deploy technologies such as MCP gateways to fill gaps in security, identity, and observability, among others (see Figure 2).

However, MCP has a critical advantage over vendor-proprietary mechanisms: it is platform-independent. Different AI agents, built by different teams on diverse agent development platforms, can use the same MCP server.
Best practices for business skills
Whether business skills are implemented as MCP servers or as other constructs, a set of best practices is proving valuable, particularly in helping CIOs keep AI costs under control.
Design for reuse. When designing a business skill for a specific AI agent, architects and developers should consider whether other agents are likely to need it later. If so, they should design the skill to serve all of those agents, not just the first one. For example, an enterprise-wide “Tax Calculation” skill that every tax-calculating agent can use is better than a tailor-made skill for each agent.
A reusable skill may cost a little more to develop, but the benefits at scale are significant: shared skills lower implementation and management costs and ensure functional consistency across agents. Reuse is often dismissed as wishful thinking, but, according to the Workato platform usage statistics, 33% of AI agents built by Workato customers reuse one or more existing business skills.
Do not overload skills. Packing too many functions into a skill makes it hard to implement, maintain, and support, and makes it slow and token-intensive for AI agents to understand it and select the right function.
Filter the payload. Business application APIs often return extremely detailed payloads. Customer data, for example, typically comes back as complex, deeply nested JSON documents that also carry non-business data such as identifiers, timestamps, and metadata. It’s tempting to have the skill pass the raw payload straight back to the agent. But if the payload has dozens of fields and the agent needs only half a dozen, the extra data clogs the context window, wasting potentially thousands of tokens and slowing performance. Bloated payloads can also confuse the model and increase security, confidentiality, and compliance risks.
Developers should therefore filter the payload within the skill and return only the data the agent actually needs. Filtering can lower the risk of hallucinations, security breaches (e.g., tool poisoning), and compliance violations. It also improves performance and, crucially, reduces token consumption.
Use composite business skills. Developers often simply wrap each individual API in a dedicated skill. This is easy to implement and makes the API functionality immediately available to AI agents. But when the agent must execute several APIs in a well-defined, deterministic process flow, this approach is suboptimal: it makes far more sense to package that flow into a single atomic composition (see Figure 3).

It doesn’t really matter whether the flow is composed with hand-written code or a low-code orchestration tool. Even if it takes a little more development effort, this approach is preferable for reasons covered in the next section. We call skills implemented by orchestrating individual API calls “composite business skills” or “process business skills.” A warning: at times, the terms “composite skill” and “composite MCP server” are used to refer to components that simply package APIs exposed by different systems. A composable business skill does the same, but, crucially, those APIs are orchestrated together to implement an execution flow.
The case for composite business skills
Improve security
The more APIs an AI agent is exposed to, the wider the attack surface. For example, malicious users could exploit prompt injection, such as tool poisoning, to convince the agent to skip certain APIs or trigger unintended ones.
If the API sequence is encapsulated in a business skill, the agent has no access to the individual APIs, only to the skill’s atomic functionality. It therefore cannot be manipulated to run only some of the API steps or to execute unintended ones. Consider a money transfer of $1,000 from bank account A to bank account B, which requires the following API sequence:
- “Check account A balance”
- “Withdraw $1,000 from account A”
- “Deposit $1,000 into account B”
The business rule is that the “Withdraw” and “Deposit” sequence may execute only if account A’s balance is at least $1,000, and the withdrawal limit is $10,000 per day (for simplicity, this example ignores the case in which one of these transactions fails).
If all three APIs are exposed to an AI agent, malicious users could use prompt injection to convince it to withdraw the entire balance from account A and deposit it into an illicit account.
Packaged into a business skill, the balance check and the daily limit run every time, and the agent can reach only the transfer itself, never the individual APIs. That’s the principle of least privilege in practice. Business skills enforce the rules, but they don’t validate intent, so high-risk skills still need input validation or human approval.
Enforce atomic transactions
Certain API sequences, such as the “Money Transfer” transaction above, must be atomic, that is, all or nothing. The sequence must complete successfully; if something goes wrong, the initial conditions must be restored as if no API had been executed. For example, if “Withdraw $1,000 from account A” succeeds but “Deposit $1,000 into account B” cannot be executed, a compensating transaction (for example, “Deposit $1,000 into account A”) must be executed to restore the original balance.
If an AI agent orchestrates the sequence, the “Deposit” API may fail because of a network issue, a model crash, or a context window overflow. The agent then has no way to roll back the “Withdraw” API call, leaving the system in an inconsistent state.
If a business skill handles the sequence, developers can enforce atomicity: if something goes wrong midway, they can design the skill to automatically run compensating transactions to restore the initial conditions. The AI agent receives only a final success or failure notification, and the system is always left in a consistent state.
Enforce deterministic behavior
AI agents are non-deterministic: their decisions depend on factors such as context, history, and triggering event data. There is, therefore, no guarantee that a sequence of API calls will be executed as intended; a hallucination or prompt misinterpretation may cause the agent to bypass or misinterpret a business rule, or to call the APIs in an inconsistent sequence.
If the API flow is hard-coded in a deterministic composite business skill, the risk is largely contained: the sequence either executes as designed, or the AI agent receives an error notification. It cannot bypass rules or trigger APIs out of sequence.
Reduce costs and latency
When an AI agent must run an API flow, it must identify the first API in the sequence, then call it, wait for a reply to come back, append the result to its context window, and reprocess the prompt history to decide the next step. For each API call, the agent burns a significant number of tokens because it must perform an inference cycle to identify the next API to call, then pass that API’s inputs and results.
Using the agent as the orchestrator is therefore expensive and slow.
If the flow for a set of APIs is deterministic, packaging it into a skill means the agent:
- performs only one inference cycle to identify the skill it needs;
- consumes tokens to pass only one set of inputs and results.
Latency and cost are therefore significantly lower. For example, a Workato customer built an employee IT support AI agent that includes a deterministic employee offboarding process. Had the agent orchestrated this process call by call, it would have required 19 inference cycles across five systems; packaged as a business skill, it requires only one cycle.
What should you do?
As a CIO, your first step is to treat agent integration as strategic: it determines how much value your agentic AI initiatives deliver. According to the Workato platform usage statistics, 91% of organizations have implemented AI agents integrated with enterprise systems; 70% of these agents connect to multiple systems, and 65% both retrieve data from and execute transactions in enterprise systems.
Specifically, you should:
- Educate business leaders on the benefits of integrating AI agents with existing enterprise systems and secure the managerial, financial, and HR support you need from top management.
- If you have an established Integration Team, upskill it into an AI Orchestration Team. This team must be responsible for building and running the infrastructure needed for fast, cost-effective orchestration between AI agents and enterprise systems.
- Give the team explicit targets for cost, ROI, and other well-defined KPIs, along with the technologies (such as AI gateways and AI control planes) and architectural frameworks (such as composable business skills) it needs to meet them.
This may look like a time-consuming and politically challenging effort, too risky to pursue, and too difficult to sell. But there is a simple, powerful argument in its favor: AI agents deliver limited value if they can only give you answers, but they are invaluable when they work alongside your enterprise systems.
Massimo Pezzini is an independent strategic advisor and Workato Head of Research, formerly a Distinguished VP Analyst at Gartner, specializing in integration, APIs, cloud computing, and composable business. Provides strategic IT advice to global organizations and is a frequent speaker on integration technologies, architecture, and industry trends. Fluent in English and Italian, with interests in food, wine, music, history, art, and travel.
If this caught your attention, that’s not accidental.
The best editorial systems don’t happen by accident. Outlever builds them.









