The Rise of AI Agents: What Changed, Why It Matters, and What Agents Need Before They Act
The rise of AI agents is the move from AI that answers to AI that acts in your systems. What changed, how agents differ from RPA, and what they need first.

The rise of AI agents is the shift from AI that answers questions to AI that takes action: software that uses a language model to plan a task, then calls tools and business systems to carry it out, step by step, until the task is done.
Two changes made it practical. Models learned to call tools through structured function calls, and open standards such as the Model Context Protocol (MCP) gave agents one common way to reach the systems where a company's data lives.
What it means for a business is easy to state and harder to do well. An agent that only reads can draft an answer. An agent that writes can create a sales order in the ERP, update a customer in the CRM or load a payment file, and each of those actions needs the controls you would put on a new employee with access to the books.
Where engini fits: engini is the layer between AI agents and the systems that run a business: ERPs, CRMs, complex financial systems, databases, files and legacy systems behind your firewall. Developers connect agents through MCP, the Python and TypeScript SDKs, the CLI or the REST API, and operations teams add an AI agent step to a no-code workflow. Toolsets limit which tools and which account an agent may use, and every run is recorded. Start with the engini docs index.
Key Takeaways
- An AI agent uses a language model to decide which step to take next, then acts through tools such as APIs, databases and business applications.
- Tool calling in model APIs, and the Model Context Protocol that Anthropic introduced on November 25, 2024, made it practical to connect agents to real systems.
- By December 9, 2025, Anthropic reported MCP support in ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code, and moved MCP to a fund under the Linux Foundation.
- System vendors now publish their own MCP servers; NetSuite's AI Connector Service is one example.
- The hard part has moved from reasoning to access: which systems an agent can reach, which actions it may take, as which account, and with what record.
What Are AI Agents?
AI agents are programs that pursue a goal by choosing and carrying out actions, with a large language model deciding what to do next. A chatbot returns text. An agent can also act: it looks up a record, creates an order, sends a message or hands work to another agent.
Most agents run the same loop:
- Receive a goal, for example "match this week's remittance emails to open invoices".
- Plan the next step from the goal and what is already known.
- Call a tool: an API call, a database query, a file read, a search.
- Read the result and decide whether the goal is met.
- Repeat or stop, and report what was done.
The tool call is what separates an agent from a chat assistant. Anthropic's documentation describes it plainly: tool use "lets Claude call functions that you define", and Claude returns a structured call that your application runs (Anthropic: Tool use with Claude). OpenAI describes function calling, also called tool calling, as a way for its models "to interface with external systems" (OpenAI: Function calling).
For a fuller definition with examples, see what agentic AI means.
Why Are AI Agents Rising Now?
AI agents are rising now because three things arrived close together: models that call tools reliably, a shared protocol for connecting those tools, and system vendors opening their own systems to agents.
Models learned to call tools. Tool calling turned a model's output from free text into a structured request that software can run. Once a model can say "call get_invoice with ID 4471" in a format your code accepts, it can work through a task one action at a time.
A shared protocol replaced one-off connectors. On November 25, 2024, Anthropic introduced the Model Context Protocol, an open standard for building "secure, two-way connections" between data sources and AI tools (Anthropic: Introducing the Model Context Protocol). Before MCP, each agent framework needed its own connector for each system. With MCP, a system exposed once as an MCP server can be used by any MCP client.
MCP spread and moved to a neutral home. On December 9, 2025, Anthropic donated MCP to the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded by Anthropic, Block and OpenAI. In the same announcement, Anthropic listed ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code among the products that support MCP, and reported more than 10,000 active public MCP servers (Anthropic: Donating the Model Context Protocol).
Systems of record opened up. Business system vendors now ship MCP access themselves. NetSuite's help center says NetSuite "has adopted the Model Context Protocol (MCP)" through its AI Connector Service, which lets an external AI client work with NetSuite data through the tools in the MCP Standard Tools SuiteApp (NetSuite Help: NetSuite AI Connector Service).
| Date | What happened | Source |
|---|---|---|
| November 25, 2024 | Anthropic introduces the Model Context Protocol as an open standard | Anthropic |
| December 9, 2025 | MCP is donated to the Agentic AI Foundation under the Linux Foundation; Anthropic lists MCP support in ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code | Anthropic |
| As of November 2026 | NetSuite documents its AI Connector Service, built on MCP, in its help center | Oracle NetSuite Help |
For how MCP itself works, see our guide to the Model Context Protocol.
How Are AI Agents Different From RPA and Workflow Automation?
AI agents differ from robotic process automation (RPA) and rule-based workflows in how they decide what to do. RPA replays a recorded script, often through the screen. A rule-based workflow follows steps you defined in advance. An agent decides each step from the goal and the data in front of it, and usually acts through APIs rather than screens.
| RPA | Rule-based workflow | AI agent | |
|---|---|---|---|
| How it decides | A recorded script | Conditions you define | A language model, from the goal and the data |
| How it acts | Usually through the user interface | Through APIs, files and databases | Through tools: APIs, files, databases, other agents |
| Handles new formats | Poorly; a changed screen or input breaks it | Only the cases you defined | Often, but it can be confidently wrong |
| Repeatability | High | High | Lower; the same input can lead to different steps |
| Best for | Stable screens with no API | Fixed steps that must run the same way every time | Reading, classifying and deciding on variable input |
That flexibility cuts both ways. A script does the same thing every time, which is what auditors want for posting a journal entry. An agent can read a remittance email in a format it has never seen, and it can also pick the wrong invoice with full confidence. The pattern that holds up in practice: let the agent read and propose, and run the fixed steps, such as posting or routing by amount, as deterministic calls or workflow steps.
What Changes When an AI Agent Can Write to Your Systems?
When an agent can write, its mistakes become business events instead of bad answers. A sales order in an ERP starts fulfillment and invoicing. A changed vendor record changes where money goes. A deleted record may be gone for good.
The failures that matter are mostly about access, not about the model:
- The wrong tool. The agent can see tools it does not need, and calls one that does more than the task requires, such as sending email from the wrong mailbox.
- The wrong account. The agent acts through a broad shared credential, so every action carries administrator rights.
- The wrong record. The agent creates a duplicate customer, or updates the record that matched a fuzzy search instead of the right one.
- No record of what happened. Nobody can say afterward which agent did what, as whom, and when.
- Systems the agent cannot reach. The core system, the on-premises ERP or the internal database sits behind a firewall that accepts no inbound traffic.
For a real case of an agent with too much access, see our analysis of agent governance after the PocketOS incident.
What Do AI Agents Need Before They Touch Business Systems?
Before an agent writes to a system of record, it needs the same boundaries a new employee gets on day one: limited access, its own identity and a record of its work.
- A limited set of tools. Give the agent only the actions its job needs, for example "read invoices" and "create vendor bill", not every action in the ERP.
- The right identity. Each action should run as a specific account with its own permissions in the target system, so the system's own security applies.
- Credentials the model never sees. The agent asks for an action; something outside the model holds the token and signs the call.
- Deterministic steps where the outcome must not vary. Fixed steps such as posting run as direct calls with exact inputs, not as model choices.
- A record of every action. What was called, with which inputs, as which account, and what came back.
- A test environment first. Run against a sandbox or development environment before production.
- Approvals where they already live. Keep approval of payments and postings in the ERP's own approval workflow, so the agent creates records and people approve them.
- A way to reach systems behind the firewall without opening inbound ports.
Tip: Start an agent read-only. Let it run for a few weeks proposing actions, compare its proposals with what your team actually did, and only then give it write tools.
Where Are AI Agents Being Used in Business Operations?
AI agents are being used first where work involves reading variable input and then acting in a known system. These are common patterns, with the systems they touch:
| Area | What the agent does | Systems it touches |
|---|---|---|
| Accounts payable | Reads an invoice, matches it to the purchase order, creates the vendor bill for approval | Email, ERP |
| Quote to order | When a deal closes, creates the customer and the sales order | CRM, ERP |
| Cash application | Reads remittance details and suggests which open invoices a payment covers | Bank files, email, ERP |
| Banking operations | Validates a clearing or transaction file and loads it into the core or ledger system with data checks | Files, core systems, databases |
| Customer support | Classifies a ticket and looks up the order or invoice behind it | Support tool, ERP, CRM |
For many more, see our list of AI agent examples and use cases.
How engini Connects AI Agents to Business Systems
engini gives AI agents governed access to the systems that run a business, including the deep and legacy ones. It is built for the point in the loop where an agent stops reasoning and starts acting.
- Systems. Deep integrations for ERPs such as NetSuite, SAP S/4HANA, SAP Business One and QuickBooks; CRMs such as Salesforce, HubSpot and Microsoft Dataverse; databases such as SQL Server, Oracle Database, IBM DB2, PostgreSQL and Snowflake; plus files and everyday apps such as Gmail, Slack and Google Sheets. Browse them on the connectors page.
- Four ways in for developers. With MCP, the model picks the tool. With the Python and TypeScript SDKs, the CLI or the REST API, your code picks it, and a tool can run deterministically with exact inputs and no model involved. The SDK hands OpenAI and Anthropic models engini's tools in the format they expect.
- No-code agents. In Workflow Studio, an AI agent step has a model, optional memory and tools from your connected systems, inside a workflow that starts on an app event, a schedule or a webhook.
- Toolsets. A toolset limits which tools an agent may call and which connection each one uses, for example read only. engini enforces it on the server: the agent only discovers the tools in its toolset, and a call outside it is refused. Toolsets scope CLI, SDK and REST API calls; an MCP server exposes only the connections and tools chosen when it is set up.
- Identity. engini acts as whoever's connection it uses: connect a user's own account and it acts as that user, with that user's permissions. Every run is recorded under the user who triggered it. Stored credentials are encrypted, and engini adds them to each call, so the agent never handles them.
- Your setup. Custom fields and custom objects are read live from each system's own configuration, for agents as well as workflows.
- Behind the firewall. The on-prem agent runs on your own server and opens every connection outbound, so you open no inbound ports. It reaches on-premises databases, file drops in local folders and network shares, and internal applications.
- Record and controls. An audit log with export and streaming to a SIEM, roles including custom roles, single sign-on, and separate development, staging and production environments. engini holds SOC 2 Type II and ISO 27001 and supports GDPR; details are on the security page.
When you do not need engini: if your agent works in one system and that vendor's own MCP server covers what it needs, start there. If your agent only reads public information or works on documents you give it, you may need no integration layer at all. engini is for agents that act across systems, including ones on your own servers, under controls your security team can review.
Agent gateway
Ship agents into systems you can’t afford to break
Connect AI agents to your ERP, CRM, financial and legacy systems through MCP, SDK, API or canvas, with secure auth, tool permissions and an audit trail built in.
Frequently Asked Questions
What does the rise of AI agents mean?
It means AI is moving from answering questions to taking actions in software, such as creating records, sending messages and running multi-step tasks. The change is driven by models that call tools and by MCP, a common way to connect those tools to business systems.
Why are AI agents becoming popular now?
AI agents became practical once models could call tools reliably and MCP gave them one standard way to reach data and systems. Anthropic introduced MCP in November 2024, and by December 2025 it listed support in ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code.
Will AI agents replace RPA?
Not everywhere. Agents handle variable input, such as unfamiliar documents, far better than scripts, while scripts and rule-based workflows remain better for fixed steps that must run the same way every time. Many teams combine them: the agent reads and proposes, and a workflow posts.
What is the difference between an AI agent and a chatbot?
A chatbot answers in text, while an AI agent also takes actions through tools, such as reading a record or creating an order. An agent works toward a goal over several steps and decides which action to take at each one.
Are AI agents safe to connect to an ERP?
They can be, if each agent is limited to the tools and account it needs, its credentials stay out of the model, and every action is recorded. Start read-only or on a sandbox, and keep approvals in the ERP's own approval workflow.
Sources
- Anthropic: Introducing the Model Context Protocol (November 25, 2024)
- Anthropic: Donating the Model Context Protocol and establishing the Agentic AI Foundation (December 9, 2025)
- Anthropic: Tool use with Claude
- OpenAI: Function calling
- NetSuite Help: NetSuite AI Connector Service
- engini docs: Scope an agent with a toolset
- engini docs: MCP client setup