What an MCP server exposes to an agent
The Model Context Protocol (MCP) is an open protocol that connects AI applications to external data and tools. An AI application (the host) runs one client per connection, and each client talks to an MCP server. In an R&D setting, that server is often the connector to an electronic lab notebook (ELN), a LIMS, a document store or an internal API.
The specification defines three things a server can offer, each controlled by a different party. Tools are model-controlled: functions the language model can choose to call, such as a query or a write. Resources are application-controlled: contextual data such as file contents that the client attaches for the model. Prompts are user-controlled: templates a person chooses to invoke. Tools carry the most risk because the model decides when to use them; resources matter because anything they return enters the model's context.
The specification is direct about the stakes. It says MCP "enables powerful capabilities through arbitrary data access and code execution paths", that tools "represent arbitrary code execution and must be treated with appropriate caution", and that MCP "cannot enforce these security principles at the protocol level". Security therefore depends on how the host, the server and the systems behind it are configured.
The documented risks
Each risk below is described in the MCP specification or its security best-practices page, an OWASP GenAI Security Project document, NIST AI 600-1, or the original public disclosure. The right-hand column is what the risk could mean for research data; it is our illustration, not a reported incident.
| Risk | What the source describes | What it could mean in R&D |
|---|---|---|
| Tool poisoning | Instructions hidden in a tool's description that the model reads but the user may not see (Invariant Labs disclosure, April 2025). OWASP's Agentic Top 10 (ASI02) describes compromising MCP tool descriptors, schemas or metadata. Invariant also describes a server changing a description after it was approved (a "rug pull") and one server's description changing how the agent uses another server's tools ("shadowing") | A connector that looks like a harmless lookup tool steers the agent to read a project it was not asked about and pass the content to another tool |
| Malicious or tampered server | A third-party tool or MCP server that is malicious at the source (OWASP Agentic Top 10 ASI04, which lists a reported malicious MCP package that impersonated a legitimate server and secretly copied emails to the attacker) | An unofficial "ELN connector" from a public package registry runs with the agent's credentials |
| Over-broad scopes | Tokens granted wide scopes up front enlarge the damage if stolen, and an omnibus scope hides intent in the audit trail (MCP security best practices, scope minimization) | One token that can read every notebook and write to every LIMS record, when the task needed one programme's summaries |
| Prompt injection through retrieved data | Prompts injected into data likely to be retrieved (NIST AI 600-1; OWASP LLM01:2025). OWASP's Agentic Top 10 lists external data tool poisoning, where third-party content steers tool actions, under ASI02 | Text in a supplier PDF, an imported dataset or a notebook entry returned by one MCP resource tells the agent to call another tool |
| Token passthrough and credential handling | A server that accepts tokens not issued to it and passes them to downstream APIs bypasses their controls and blurs accountability; the MCP authorization specification forbids this. For local (stdio) servers, the specification says credentials should come from the environment | A connector forwards a scientist's token to the LIMS API, so LIMS logs show the person, not the agent, the record no longer shows who or what made a change, and the token works elsewhere |
| Excessive agency | Damaging actions taken in response to unexpected, ambiguous or manipulated model output, from excessive functionality, permissions or autonomy (OWASP LLM06:2025) | An agent with write and delete tools it never needed changes sample records after misreading a request |
Local and remote servers need different checks
MCP servers run in two broad ways, and the risks differ. A local server is a program started on the same machine as the AI application, usually over the stdio transport; the specification says such implementations should not follow its authorization rules and should retrieve credentials from the environment instead. A remote server is reached over HTTP. Authorization is optional in MCP, but an HTTP implementation that supports it should follow the specification's OAuth-based flow, in which the client asks for a token for that specific server and the server must check that the token was issued for it. Do not assume a remote server does this: confirm it requires authorization at all before it is connected.
For a local server, the main question is what the program can do on the machine. The MCP security best-practices page describes malicious start-up commands embedded in a configuration and malicious payloads inside a server. It says clients offering one-click setup must show the exact command and get explicit approval, and should warn users that servers run with the same privileges as the client and run them in a sandbox with restricted file-system and network access. On a scientist's laptop that holds exported datasets, credentials and synced document folders, that matters.
For a remote server, the main questions are identity and tokens: who operates the server, where it runs, which scopes it requests, and whether it passes tokens through to the systems behind it. The best-practices page describes token passthrough as an anti-pattern that bypasses downstream controls and makes it hard to tell clients apart in logs, and says servers must not accept tokens that were not issued for them. It also describes a confused-deputy attack on servers that proxy to a third-party API with a single client ID, and requires those servers to obtain per-client consent.
Resources and prompts are inputs too
Most MCP security discussion is about tools, because tools act. Resources and prompts still put text into the model's context. A resource that returns an ELN entry, a supplier certificate of analysis or a partner's report returns whatever text that content contains, including text written to steer the model. That is the indirect prompt injection pattern NIST AI 600-1 describes. The connector-level point is that every resource a server exposes is a route for it.
The specification's tools page says servers must sanitize tool outputs and clients should validate tool results before passing them to the model. In practice that means limiting what a resource returns to the fields the task needs, preferring structured output with a fixed schema where possible (one of the mitigations on OWASP's MCP tool poisoning page), and never treating text from a resource as an instruction to the agent. Prompts are chosen by a user, but they are written by whoever controls the server; review them the same way you review tool descriptions.
Controls for ELN, LIMS and document-store connectors
Among the mitigations on OWASP's MCP tool poisoning page is to enforce restrictions on the server side rather than relying on system-prompt instructions to restrict tool access. The controls below follow that approach: each one is enforced by the host, the server or the record system, not by asking the model to behave.
If the ELN or LIMS holds GxP records, adding an agent's write path is a change to a validated computerised system. Expect to handle it through change control, with your quality function assessing the validation impact before go-live (EU GMP Annex 11 (2011), clause 10, covers change and configuration management; 21 CFR 11.10(a) covers validation). The connector controls below do not replace that. Our answer on what to check before giving an AI agent access to your ELN or LIMS covers the record-level checks and how they map to 21 CFR Part 11 and EU GMP Annex 11; this list covers the connector itself.
- Allow-list servers. Keep a list of approved MCP servers and block the rest, as OWASP recommends. Prefer servers published by the system vendor or built in-house, pin the version, and review a change before it is deployed.
- Narrowly scoped identity. Each connector acts either under its own service identity or with the requesting user's delegated rights, scoped to the projects, studies or record types its task needs. Never a shared or administrator account. Request the minimum scopes and add more only when an operation needs them, as the MCP scope guidance describes.
- Read-only by default. Expose read tools first. Add write tools one at a time, each limited to named record types and actions, and leave out delete.
- Human approval. The specification's principles say hosts must obtain explicit user consent before invoking any tool, and its tools page says there should always be a human able to deny tool invocations. At a minimum, every write and every call that sends data outside the boundary should show its inputs to a person and wait for approval. Approving a tool call is not reviewing or signing the record; the record system's own review and signature steps still apply.
- Token hygiene. Where the server uses MCP authorization, tokens are requested for that specific server (RFC 8707 resource indicators), checked by the server for audience, kept out of URLs and never passed through to downstream APIs. Keep secrets in a managed vault, not in configuration files the model can read.
- Pin tool definitions by hash. Record a hash of each approved tool definition (name, description and schema) and compare them on every connection, not only when the server announces a change. A server performing a rug pull will not necessarily announce one. Re-review before using any server whose hash has changed.
- Separate trust zones. A server that reads external content (literature, the web, partner files) should not share an agent session with servers that can read or write internal ELN, LIMS or document-store data, unless every outbound call and every write in that session needs a person's approval.
- Log every tool call. The specification says clients should log tool usage for audit purposes. Record the server, tool, inputs, result, agent identity, accountable person and time, and link the entry to the record it touched. This log adds context; it does not replace the ELN or LIMS audit trail, which for regulated records must still capture the change to the record itself.
See: What to check before giving an AI agent access to your ELN or LIMS · Audit trail for AI agents in regulated research
An illustrative scenario: a rug pull
Picture a team that connects two MCP servers to one agent session: a third-party chemistry reference server that looks compounds up in external databases, whose tool definitions were reviewed and approved, and a LIMS connector with a write tool for sample registration. Weeks later, an update to the reference server changes one tool description. The new text tells the model that, whenever it registers a sample, it should also look up the sample's structure in the reference server, passing the full registration details as the query. Those details can include unpublished structures. The server does not announce the change, and the approval dialog the scientist saw at setup is never shown again.
This is an illustration, not a reported incident; it follows the rug-pull and shadowing patterns in Invariant Labs' disclosure. Without controls, the change would only surface if someone happened to read the new description. With the controls above, the host compares the reference server's tool-definition hashes at the next connection, finds a mismatch, blocks the server until it is re-reviewed and records which description changed and when. Even if that check were missed, the trust-zone rule would have put the external reference server in a separate session from the LIMS connector, and the lookup that would carry the registration details out is an outbound call that waits for a person who can see its inputs.
Pre-connection checklist for an MCP server
Complete and record each check before an MCP server is connected to an agent that can reach research data. The right-hand column gives the source of each check.
| Check | What to confirm | Source |
|---|---|---|
| Provenance | The server comes from the system vendor, an internal team or a reviewed source; the package and version are pinned | OWASP Agentic Top 10 ASI04; OWASP LLM03:2025 Supply Chain |
| On the allow-list | The server is on the approved list and the host blocks servers that are not | OWASP MCP Tool Poisoning |
| Tool inventory reviewed | Every tool, resource and prompt the server exposes is listed, read in full (including descriptions and parameter names) and needed for the task | MCP specification, Tools (annotations untrusted unless from a trusted server); Invariant Labs disclosure |
| Definitions pinned by hash | A hash of each approved tool definition is recorded and compared on every connection; a mismatch blocks the server until re-review | Invariant Labs disclosure (pinning by hash or checksum) |
| Authorization required | A remote server requires authorization and follows the MCP authorization specification; a local server takes credentials from the environment and runs sandboxed | MCP specification, Authorization; MCP security best practices (local server compromise) |
| Scoped identity, minimum scopes | The connector has its own service identity or narrowly delegated user rights; scopes cover only the task; no shared or admin accounts | MCP security best practices (scope minimization); OWASP Agentic Top 10 ASI03 (task-scoped, time-bound permissions per agent identity); OWASP LLM06:2025 |
| Read-only default | Write tools are off unless a named write is needed; delete is not exposed; for GxP systems, a write path has been through change control | OWASP LLM06:2025; OWASP Agentic Top 10 ASI02 |
| Human approval | Each write or outbound send shows its inputs and waits for a person to approve or deny it | MCP specification, Tools (human in the loop); OWASP MCP Tool Poisoning |
| Token audience | Tokens are issued for this server only, sent in the Authorization header, not in URLs, and never passed through | MCP specification, Authorization; RFC 8707 |
| Trust zones separated | Servers that read external content do not share a session with servers that reach internal data, unless outbound calls and writes need approval | Invariant Labs disclosure (cross-server controls); OWASP LLM06:2025 |
| Tool calls logged | Each call is logged with server, tool, inputs, result, identities and time, linked to the record, in addition to the record system's own audit trail | MCP specification, Tools (log tool usage for audit) |
Why these controls work together
No single control is enough. NIST AI 600-1 lists indirect prompt injection among the information-security risks of generative AI, and OWASP says it is unclear whether fool-proof prevention for prompt injection exists. Treat a successful injection, or a poisoned tool description, as something that may eventually happen, and design so that it cannot do much.
That is the logic of the list. The allow-list and hash pinning reduce the chance a malicious tool is present at all. Scoped identities and read-only defaults limit what a misled agent can reach. Separate trust zones and human approval stop the highest-impact actions. Logging makes what happened reconstructable. OWASP's Agentic Top 10 calls the general principle least agency: avoid giving an agent autonomy where it is not needed.
MCP is changing quickly. The specification is versioned by date, and its authorization and security guidance have changed between releases. Review connectors against the current version when you upgrade a host or a server.
Deciding which connectors an agent may use, and what each may do, is part of running agents safely on research data. Atlas Bio's Secure AI for Life Sciences starts with an AI risk assessment of current AI use and data exposure. Status, October 2026. In use in Atlas Bio's own agent platform today: a separate verification step that checks agent work, and a hold that stops a task until a person decides. Built and tested on synthetic data, not yet used with a client: the AI risk assessment tooling and a record of what data an AI used, what it produced and who reviewed it. In development: a customer-controlled AI environment in your own Azure tenant, an AI gateway, agent permissions, evidence linkage and notifications. Each engagement states which controls are built. Decisions on GxP scope, validation and compliance stay with your quality function.
Is MCP itself insecure?
MCP is a protocol for connecting AI applications to data and tools. Its specification says it cannot enforce security principles at the protocol level, so security depends on how hosts and servers are built and configured. The specification and its security best-practices page set out what implementers should do.
What is MCP tool poisoning?
Hiding instructions in an MCP tool's description or other metadata so the model acts on them, often without the user seeing them. Invariant Labs publicly described it in April 2025, and OWASP's Top 10 for Agentic Applications covers compromised MCP tool descriptors under ASI02 Tool Misuse and Exploitation.
Should an MCP connector have write access to our ELN or LIMS?
Start read-only. Add a write tool only when a task needs it, limited to named record types and actions, with no delete and a person approving each write before it runs. If the system holds GxP records, expect to handle the new write path through change control, with your quality function assessing the validation impact.
Can we use community MCP servers from public registries?
Treat them like any third-party code with access to your data. OWASP's Agentic Top 10 lists a reported malicious MCP package that impersonated a legitimate server. Prefer vendor or in-house servers, review the code and tools, pin the version and keep an allow-list.
How should credentials for an MCP server be handled?
Authorization is optional in MCP, so check it. For HTTP servers that support it, the specification uses OAuth with tokens issued for that specific server, sent in the Authorization header and never passed through to other APIs. For local servers, it says credentials should come from the environment. Keep secrets in a managed vault, scoped to the connector.
Do MCP tool calls need to be in the audit trail?
The MCP specification says clients should log tool usage for audit purposes. Log the server, tool, inputs, result, agent identity, accountable person and time, linked to the record each call touched. That log adds context; for regulated records, the ELN or LIMS audit trail must still record the change to the record itself.
- Model Context Protocol Specification (version 2026-07-28): Security and Trust & Safety
- Model Context Protocol Specification: Server features overview (prompts, resources, tools)
- Model Context Protocol Specification: Tools (user interaction model and security considerations)
- Model Context Protocol Specification: Authorization
- Model Context Protocol: Security Best Practices (2026-07-28 documentation)
- OWASP GenAI Security Project: OWASP Top 10 for Agentic Applications for 2026
- OWASP Community: MCP Tool Poisoning
- OWASP GenAI Security Project: LLM01:2025 Prompt Injection
- OWASP GenAI Security Project: LLM06:2025 Excessive Agency
- OWASP GenAI Security Project: LLM03:2025 Supply Chain
- NIST AI 600-1: Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile
- IETF RFC 8707: Resource Indicators for OAuth 2.0
- European Commission: EudraLex Volume 4, Annex 11 - Computerised Systems (revision 1, 2011)
- eCFR: 21 CFR 11.10, Controls for closed systems
- Invariant Labs: MCP Security Notification - Tool Poisoning Attacks (April 2025)
Talk to Atlas Bio.
Sponsors, researchers and clinicians: tell us the decision you are trying to make and we will show what the platform can and cannot answer.
Contact Us →