AI delivery · Agent tooling

Let agents use your internal tools through MCP without handing them the keys

If you want AI agents or assistants to use internal systems through the Model Context Protocol, you can commission me to build that integration with controlled access. I inventory the tools, decide what each may do and on whose behalf, implement MCP servers with scoped credentials, approvals and audit logging, prove the controls with negative tests, and hand the servers to your platform team.

This is a good fit if…

  • You want agents or assistant clients to read from and act on internal systems (ticketing, CRM, data warehouse, internal APIs) through MCP.
  • Security has asked how agent tool calls are authenticated, authorised, rate-limited and logged, and nobody has a good answer yet.
  • Teams are already wiring up community MCP servers with broad personal tokens, and you need a controlled pattern before it spreads.
  • You have a platform team that will run the servers after launch.

Look elsewhere if…

  • You need the full agent built, including planning, state and recovery. Use production AI agents and agent infrastructure, which includes this as one part.
  • Your agents already have tool access and the gap is approval tiers and stop conditions for consequential actions. Governed AI agent implementation is more specific.
  • You only want a desktop assistant connected to a few personal productivity tools. That is a configuration task, not a delivery.

What you get

Tool inventory, permissioned integration, negative tests and operational handover

  • A tool inventory listing each capability, the system behind it, its data sensitivity, its side effects and its owner.
  • MCP servers that act on behalf of an identified user or service, with per-tool scopes instead of a shared admin credential.
  • Approval steps for tools with consequential side effects, and rate limits on every tool.
  • Structured audit events for every tool call: who, which agent, which tool, which arguments, what result.
  • A negative test suite proving that out-of-scope calls, injected instructions and malformed arguments are refused.
  • A runbook and handover to the platform owner.

How it runs

  1. 01

    Brief and fit check

    You describe the systems, the agent clients and who will use them. I reply with questions and a view on fit before anything is signed.

  2. 02

    Tool inventory and access design

    With system owners and security, I list candidate tools, classify each by data sensitivity and side effect, and decide identity, scopes and approvals per tool.

  3. 03

    Build the servers

    MCP servers are implemented in your repositories against your systems' APIs, with authentication, scoped authorisation, input validation, rate limits and audit logging.

  4. 04

    Negative testing

    A test suite tries what should fail: calls outside scope, prompt-injected instructions in tool results, oversized or malformed arguments, expired credentials.

  5. 05

    Acceptance and handover

    The security sponsor and platform owner review results against the agreed criteria, then take over deployment, credentials and the runbook.

What needs to be in place

  • A defined set of systems in scope and an owner for each who can agree what agents may do there.
  • Your identity provider and the way users and services should be represented in tool calls.
  • API access to the target systems in a non-production environment for building and testing.
  • A security sponsor who will review and accept the access design.

Not included

  • Building or changing the target systems themselves beyond adding API access where needed.
  • Approving or vetting third-party MCP servers for use across your organisation.
  • Agent planning, memory and multi-step recovery, which belong to the agent build and recovery routes.
  • Production on-call for the servers after handover unless agreed separately in writing.

The situation

The Model Context Protocol has made it easy to connect an AI agent or assistant to tools: a ticketing system, a CRM, a database, an internal API. That ease is the problem. In many organisations, MCP servers are appearing with a developer’s personal access token, no distinction between reading and writing, no rate limits and no log of what the agent actually did.

When the question reaches a platform lead or security sponsor, it is usually framed like this: we need agents to use internal tools through MCP; how do we design identity, authorisation and safe failure handling so we can say yes?

This page is for commissioning that integration as a bounded delivery, with controls you can test and a team that can run it.

What the work involves

Inventory before integration. I work with each system owner to list the capabilities an agent might need, then classify each: what data it exposes, what side effects it has, whether those side effects can be reversed, and who owns the system. Read-only lookups and irreversible actions should not share a credential or an approval rule.

Identity and scopes per tool. For each tool we decide whose authority the call runs under. Delegated user access means the agent can never see more than the person it is acting for. A service identity is narrower and used where delegation is not possible. Scopes are defined per tool, default-deny, so an agent cannot discover and call something it was not granted.

Controls outside the model. This follows the Substrate Pattern I have published: the model can propose any call, but a layer it cannot bypass decides whether the call happens. Concretely that means schema validation on every argument, rate limits per tool and per identity, approval steps for consequential actions, and timeouts and clear error results so agents fail safely rather than retrying blindly.

Audit by design. Every call emits a structured event: user, agent, tool, arguments (with sensitive fields masked), result and latency. Security can answer “what did the agent do, for whom” without reconstructing it from application logs.

The signature deliverable

You receive the tool inventory, permissioned integration, negative tests and operational handover. Illustrative example of a tool inventory extract:

ToolSystemSide effectRuns asControl
search_ticketsTicketingNoneDelegated userScope: read; rate limit
add_ticket_commentTicketingReversibleDelegated userScope: comment; audit
issue_refundBillingIrreversible, financialService identityHuman approval; amount ceiling; audit
run_sqlWarehouseNoneRead-only roleAllow-listed views only; row limit

Illustrative example showing the format, not a client deliverable.

How acceptance is judged

Acceptance criteria are agreed after the access design: every tool in scope is implemented with its agreed identity, scope and controls; the negative test suite passes, meaning every out-of-scope, injected or malformed call is refused and logged; approval steps cannot be skipped; and audit events are complete for a sample of real calls. The security sponsor and platform owner sign off.

Ownership and handover

The servers live in your repositories and run in your infrastructure. The platform owner receives deployment configuration, the credential rotation procedure, the process for adding a new tool through the same inventory and test steps, and guidance on reading the audit trail. I do the work personally; any specialist help is disclosed and approved by you first. Independent practitioner; not affiliated with or endorsed by Anthropic or the MCP maintainers.

Boundaries

If you need approval tiers, stop conditions and adversarial policy testing for agents that already take real actions, see governed AI agent implementation. If agent workflows fail halfway and retries repeat actions, see agent reliability and recovery engineering. If you need the whole agent built, start at production AI agents and agent infrastructure. If the tools exist to serve one business workflow, AI workflow automation may be the better frame.

Questions buyers ask

Can't we just use existing open-source MCP servers?

Sometimes, for read-only tools against low-sensitivity data. Many community servers assume a single user with a broad personal token and do little authorisation or logging. For systems with real side effects, I usually wrap or replace them so identity, scopes, approvals and audit sit in code you control and test.

How do you handle identity when an agent acts for a user?

The design decides, per tool, whether a call runs as the user (delegated access, so the agent can never see more than that person could) or as a narrowly scoped service identity. Either way the audit event records the human, the agent and the tool, so actions are attributable.

What about prompt injection through tool results?

It cannot be prevented by prompts alone, so the controls sit outside the model: scopes limit what any call can reach, consequential tools need approval, and arguments are validated against schemas. The negative test suite includes injected instructions in tool outputs to show those controls hold.

Are you affiliated with Anthropic or the MCP project?

No. I am an independent practitioner, not affiliated with or endorsed by Anthropic or any MCP maintainer. MCP is an open protocol and changes over time, so I check the current specification at the start of each engagement rather than relying on older assumptions.

Who maintains the servers afterwards?

Your platform team. The handover covers deployment, credential rotation, adding a new tool through the same review, reading the audit log and responding to a refused or suspicious call. Adding tools later follows the inventory and test pattern rather than ad hoc wiring.

Describe what needs to work

A short, non-confidential description is enough to start. I read every brief personally and reply within two business days, including when the answer is that I am not the right fit.

Step 1 of 2 · The basics