Skip to content
← Blog

How to Connect an AI Agent to Company Systems

7 Jul 2026 · RS Management

TL;DR

  • MCP is already an industry standard, but its specification is still changing fast.
  • For one integration called from one place, a plain script still wins on lower entry cost and predictable permissions.
  • Four controls limit the damage of an attack whichever route you choose.

“We want an AI agent to update Jira tickets and read documents from SharePoint on its own. How do we connect it?” The connection method is often treated as a technical detail for the team to settle. Yet it determines how much the integration costs to maintain, who can call it and whether after an incident you can reconstruct exactly what the agent did. This applies to every system holding data: Jira, SharePoint, a data warehouse, an ERP system (enterprise resource planning) or an internal API (application programming interface).

Two ways to connect a tool

MCP (Model Context Protocol) CLI (command line interface)
What it is An open protocol: the agent discovers tools exposed by a server and calls them The agent is allowed to run a specific command or script
Contract One shared language for all clients: an assistant in the code editor, a chat app, your own agent Arguments, exit code and data format on standard output
Where permission logic lives In the protocol and the server In code the team wrote itself

MCP standardizes how capabilities are described, how permissions are negotiated and how results are passed. A script leaves those decisions to the team, which is an advantage with one integration and a problem with ten.

State of the protocol in July 2026

On 9 December 2025 MCP moved to the Agentic AI Foundation, a fund run under the Linux Foundation and co-founded by Anthropic, Block and OpenAI, with support from Google, Microsoft, AWS, Cloudflare and Bloomberg. The announcement cited more than 10,000 active MCP servers and more than 97 million monthly SDK downloads.1 A public server registry has been running since September 2025.

The current specification is dated 2025-11-25, but the shape of the next one is already fixed. On 21 May 2026 a release candidate for version 2026-07-28 was published, with the final version scheduled for 28 July. It is the largest change since the protocol launched: a stateless core without session negotiation, capability negotiation per request, tightened authorization rules and an extensions framework.2 The changes break backward compatibility, so an integration written today for version 2025-11-25 needs a review before its libraries move to the new specification.

The standard has the backing of the largest providers and is changing fast at the same time. An MCP integration needs budget for regular updates and compatibility testing too.

When MCP pays off

  1. The same tool called from several places. One server serves an assistant in the code editor, a chat app and your own agent instead of three separate integrations maintained by three people.
  2. The system vendor maintains the server. Compatibility with successive API versions stops being the team’s cost and becomes part of a product the vendor is responsible for.
  3. Per-user permissions. When access is granted to each person separately, with token refresh and revocation, the protocol’s authorization layer does work that would otherwise be written by hand.
  4. A changing set of tools. When the catalog of functions changes every few weeks, discovering tools at runtime is more convenient than updating prompts with every change.

When a script is enough

For one integration called from one place, an MCP server adds a layer that returns nothing. If the repository already holds a tested script for issuing invoices or updating tickets, letting the agent call it is cheaper than rewriting it for the protocol.

A script also wins on high-stakes operations, where a narrow and rigid surface matters. Five explicitly defined commands are easier to review in code review than a server with forty tools the agent chooses from on its own.

A split between reading and writing also works well. Reading data goes through the vendor’s ready MCP server, because it is convenient and does not change the system’s state. Every write goes through your own script, with the credential in environment variables and a log of every call. The company then maintains two mechanisms instead of one, and in return every state-changing operation has an explicit path and leaves a trace.

Splitting reads and writes

  1. AI agent
    • readVendor MCP serverready-made, does not change system state
    • writeYour own scriptcredential in environment variables, every call logged
  2. Company systeme.g. Jira, SharePoint, ERP
Two mechanisms instead of one. In return every state-changing operation has an explicit path and leaves a trace.

The cost of context

Tool definitions take up space in the model’s context. With a dozen or so connected servers the catalog alone can take tens of thousands of tokens before the agent does anything. In November 2025 Anthropic described a pattern for calling MCP tools from code run in an isolated environment: definitions loaded on demand, intermediate data processed in code and only the finished result passed to the model. In the example described, the task dropped from about 150,000 to about 2,000 tokens.3 It is one documented case, so the numbers do not transfer directly to other environments, but the direction is clear: MCP provides the tool description, and execution ends up in code anyway.

  • c. 150,000tokens in the example task when definitions and intermediate data pass through the model context
  • c. 2,000tokens for the same task when code calls the tools and the model receives the finished result
Dimension MCP CLI and scripts
Entry cost Higher: server, permissions, upkeep Low: what the team already has
Context usage The tool catalog takes space in the prompt Zero until called
Resilience to API changes Tool description in one place Each script separately
Who owns the code The server may be external The code belongs to the company and can be audited
When it wins Many systems, frequent changes A few systems, stable interfaces

Security and the audit trail

On 15 April 2026 researchers described a class of attacks called “Comment and Control”.4 Content injected into a pull request title or an issue comment took over agents run automatically in GitHub Actions, including Claude Code Security Review, Gemini CLI Action and GitHub Copilot Agent, and led them to exfiltrate secrets from the runtime environment. The vendors paid bug bounties for the reports, without public CVE identifiers (the catalog of publicly known vulnerabilities).

An agent treats the content it reads as trusted context, so its permissions become the attacker’s permissions. The extent of the damage is limited by four controls applied together:

  1. An allowlist of tools.
  2. An identity attached to every call.
  3. A log of the arguments and result of every call.
  4. Human approval for irreversible operations.

In a conversation with auditors a script has the edge: the call log appears by itself and the permission boundary is visible directly in the code. With MCP the audit has to be designed deliberately, because the call passes through a layer the team did not write.

Four questions before choosing

Question Points to MCP when Points to a script when
How many clients will call the tool within a year? Several One
Who maintains the server? The system vendor You would have to write it yourself
Is the operation reversible? Yes, e.g. reading No, e.g. writing or payment
Does a tested script already exist? No Yes

The choice is made separately for each integration, with a short written rationale, because within a few months both the protocol versions and the list of ready servers maintained by vendors will change. We review agent integrations and design permissions as part of the AI Automations & Agents package.

Frequently asked questions

What is MCP?

MCP (Model Context Protocol) is an open protocol through which an AI agent discovers and calls tools exposed by a server, such as access to Jira or SharePoint. Since December 2025 it has been developed by the Agentic AI Foundation under the Linux Foundation.

When is a script better than MCP?

When the integration has one client, the operation is irreversible or the company already has a tested script. The script is then cheaper and easier to audit.

How do you secure an AI agent connected to your systems?

With four controls together: an allowlist of tools, an identity on every call, a log of arguments and results and human approval for irreversible operations.

Footnotes

  1. Model Context Protocol, 9 December 2025 announcement of the move to the Agentic AI Foundation, including the server and SDK download figures: https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/. ↩

  2. Model Context Protocol, announcement of the release candidate for the next specification version, 21 May 2026: https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/. ↩

  3. Anthropic, the pattern for calling MCP tools from code: https://www.anthropic.com/engineering/code-execution-with-mcp. ↩

  4. Cloud Security Alliance, research note on AI agents in GitHub Actions exfiltrating secrets: https://labs.cloudsecurityalliance.org/research/csa-research-note-comment-control-github-prompt-injection-20/. ↩

Blog content is informational and educational. It does not constitute legal or tax advice, nor individual business advisory. The scope of our services is described in the terms.

See the package: AI Automations & Agents