# One MCP for Claude Code, Codex and Devin: Give Every Agent the Same Company Context


URL: https://getunblocked.com/blog/one-mcp-for-claude-code-codex-devin/
Published: 2026-10-19T14:00:00Z
Author: Brandon Waselnuk
Categories: Context Engine, AI Agents

Three agents and five source MCPs is 15 configs and 5 auth flows per developer. How one MCP gives Claude Code, Codex and Devin the same company context.

---
Yes: one MCP server placed in front of your sources gives Claude Code, Codex and Devin the same company context, because all three speak the same protocol and differ only in where the config lives. The cost of the alternative is measurable. A March 2026 arXiv study found that five MCP servers (filesystem, MySQL, Slack, GitHub and a time/weather server) exposed 121 tools between them. At 100 tools, the paper estimates 20,000 to 80,000 tokens per request before the agent does any work ([arXiv 2603.20313](https://arxiv.org/html/2603.20313v1), 2026). Multiply that by three agents and you have the problem this page answers. Unblocked's MCP server is the worked example throughout: it delivers institutional context for coding agents through a single endpoint, and the setup shape for each agent is below.

## Is there a single MCP that gives Claude Code, Codex and Devin the same company context?

There is, and it works because **The Model Context Protocol (MCP)** is an open standard rather than a product: any compliant client can register a server that speaks Streamable HTTP. The current specification, dated July 28, 2026, defines stateless, self-contained requests and per-request capability negotiation, so the same server behaves the same way for each host ([MCP specification](https://modelcontextprotocol.io/specification/2026-07-28), 2026).

What differs is the registration step. Claude Code stores servers in `~/.claude.json` or a project `.mcp.json`, Codex in `~/.codex/config.toml`, and Devin in its MCP settings page. Point all three at the same URL and each agent gets the same tools, the same index and the same answer to "why does the billing retry live in that service".

Unblocked's hosted server is the concrete case. Its endpoint is `https://getunblocked.com/api/mcpsse` and it authenticates by OAuth or a bearer access token ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/install-other)). It exposes two tools. `context_research` runs a multi-source search across code, PRs, docs, issues and messages and returns a cited answer; `context_get_urls` fetches the content behind known links ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/mcp-overview)). The agents stay different; the company context they start from does not.

## Why do three agents and five source MCPs turn into fifteen configurations?

Because MCP configuration is per client and per server, with nothing shared between them. Anthropic's own tool-use docs put a five-server setup of GitHub, Slack, Sentry, Grafana and Splunk at about 55,000 tokens of tool definitions before any work starts. The same page notes that tool selection accuracy degrades once an agent has 30 to 50 tools available ([Anthropic](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool), living docs).

Now do the arithmetic for a team running Claude Code, Codex and Devin against GitHub, Slack, Jira, Confluence and Notion. Each agent holds its own copy of each server entry: fifteen configurations. Each developer signs in to each source once per agent that keeps its own token store, so five OAuth flows per developer at minimum. And every call carries every tool definition, whether or not the question touches Slack.

Advidi's CTO, Jorden van Breemen, tried this setup first. With the native GitHub, Confluence and Jira servers, he described the result as extreme context bloat: an agent loads all of your Confluence documentation or crawls all of Jira. That is a token-expensive job that still references outdated documentation ([Advidi customer story](https://getunblocked.com/customers/advidi/)). The MCP maintainers' March 2026 roadmap lists configuration portability, SSO-integrated auth and gateway behavior under enterprise readiness and calls that area "the least defined" ([MCP roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/), 2026). The protocol will not undo the multiplication for you yet.

## How do you give Claude Code and Cursor context from Slack and Jira without installing separate MCP servers?

Register one server that already indexes Slack and Jira, and skip the vendor servers for read-only questions. Cursor reads `~/.cursor/mcp.json` globally or `.cursor/mcp.json` per project, supports Streamable HTTP, and signs in to remote servers with the OAuth authorization code flow with PKCE ([Cursor docs](https://cursor.com/docs/context/mcp), living docs).

Unblocked unifies PRs, Slack, Jira, Notion, Confluence and code repos behind that one entry, so the Cursor config is seven lines:

```json
{
  "mcpServers": {
    "unblocked": {
      "url": "https://getunblocked.com/api/mcpsse"
    }
  }
}
```


Save it, click Connect, sign in ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/install-cursor)). Claude Code takes the same URL from a single command, shown in the next section. Neither agent now needs the Slack server or the Atlassian server loaded to answer a question such as "what did we decide about rate limits in the platform channel last quarter". Keep the vendor servers for writes, for example filing a Jira ticket or posting to Slack; that is still their job. Which sources deserve a connection at all is covered in [our Slack, Jira and Confluence knowledge guide](https://getunblocked.com/blog/give-agents-slack-jira-confluence-knowledge/).

## Where does each agent's MCP config live, and what does the setup look like?

Four agents, four config locations, one URL. Claude Code's `claude mcp add` writes to `~/.claude.json` at user scope or `.mcp.json` at project scope. Codex uses `~/.codex/config.toml`, Devin manages servers on the Customize, MCPs tab, and Cursor uses `mcp.json` ([Claude Code docs](https://code.claude.com/docs/en/mcp); [Codex docs](https://learn.chatgpt.com/docs/extend/mcp?surface=cli); [Devin docs](https://docs.devin.ai/work-with-devin/mcp), all living docs).

| Agent | Where its MCP config lives | Transport | Auth |
| --- | --- | --- | --- |
| Claude Code | ~/.claude.json (user or local scope) or .mcp.json (project); managed-mcp.json for enterprise rollout | HTTP (--transport http) | OAuth via /mcp, or a bearer header |
| Codex | ~/.codex/config.toml, one [mcp_servers.name] table per server | Streamable HTTP (url field) | codex mcp login, or bearer_token_env_var |
| Devin | Customize, MCPs tab; Add custom MCP (needs the Manage MCP Servers permission) | HTTP, not SSE | Auth Header with a team token, or OAuth |
| Cursor | ~/.cursor/mcp.json (global) or .cursor/mcp.json (project) | Streamable HTTP | OAuth with PKCE on Connect, or headers |


### Claude Code

```bash
claude mcp add -s user --transport http unblocked https://getunblocked.com/api/mcpsse
```


Then run `/mcp`, pick `unblocked`, and sign in through the browser ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/install-claude-code)). A platform team can push the same entry to every laptop through `managed-mcp.json`, which ranks above user and project config.

### Codex

```toml
[mcp_servers.unblocked]
url = "https://getunblocked.com/api/mcpsse"
```


Then `codex mcp login unblocked` opens the browser sign-in ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/install-codex)). For headless runs, `bearer_token_env_var` names the environment variable that holds a team token.

### Devin

Devin has no config file to edit. Someone with the Manage MCP Servers permission opens Customize, MCPs, chooses Add custom MCP, sets the URL above, selects HTTP as the transport, and sets Auth Header to `Authorization: Bearer <team token>`. Devin also offers SSE, and that option fails here. Unblocked's docs state that HTTP+SSE is deprecated in the MCP specification and not supported by its server, and tell you to select HTTP when a client offers the choice ([Unblocked docs](https://docs.getunblocked.com/unblocked-mcp/install-other)). Organization-scoped access shares one authenticated connection, so scope the team token to the sources Devin needs.

## What does satisfaction of search mean for tokens per call?

**Satisfaction of search** means the server keeps searching until the question is answered, then returns only the answer, so the agent never pays for raw pages. We measured the difference with one run of the open-source unblocked-compare harness: same prompt, same model (claude-sonnet-4-6), same repository and turn budget, with Unblocked's MCP server attached in one arm and no MCP server in the other. The arm with Unblocked used 42% fewer tokens and made 64% fewer tool calls (Unblocked A/B test, 2026). That is a single run, so treat it as a data point and repeat it on your own repository; the full write-up is in [same prompt, same model, different context](https://getunblocked.com/blog/same-prompt-same-model-different-context/).

A native source server answers the literal query: "search Confluence for retry policy" returns the matching pages, including the one from 2023. The agent reads them, notices a conflict with the code, and searches again. **A context engine** is the server-side layer that runs that retrieval loop instead of the agent. It pulls candidates from every source and checks whether they resolve the question. If they don't, it follows the thread into the PR or the ticket, discards the stale version when a newer decision supersedes it, and stops when the answer is grounded. The agent receives one synthesized, cited response and makes one call. The mechanics are in [Inside the Unblocked context engine](https://getunblocked.com/blog/inside-the-unblocked-context-engine/).

That is also why the tool count stays at two: the engine does the discovery, so the agent carries no catalog. We measured what large catalogs cost in [MCP tool overload](https://getunblocked.com/blog/mcp-tool-overload/). The arXiv study above found that retrieving only three tools per query put a relevant tool in that top three 97.1% of the time on the authors' 140-query benchmark, while cutting tool-related tokens by 99.6% ([arXiv 2603.20313](https://arxiv.org/html/2603.20313v1), 2026).

## Everyone on the team connects their own MCP servers and context isn't centralized: what fixes this?

A single shared endpoint that every agent and every developer registers, plus a policy that stops the laptop sprawl. Claude Code's `managed-mcp.json` ranks above user and project config and supports `allowedMcpServers` and `deniedMcpServers`; Devin lets an organization-scoped server reach every member from one install ([Claude Code docs](https://code.claude.com/docs/en/mcp); [Devin docs](https://docs.devin.ai/work-with-devin/mcp), living docs).

The sprawl has two halves that need different fixes. Access governance, meaning which servers may run and who holds the credentials, belongs to a gateway or a managed allowlist; [our guide to centralizing context for coding agents](https://getunblocked.com/blog/centralize-context-for-coding-agents/) compares those routes. The second half is the answers. Even with a perfect allowlist, ten engineers' agents each reconcile Slack, Jira and GitHub on their own and land on ten versions of the truth. Centralizing that half means one server is the first MCP queried for any "why" question, with permissions enforced at retrieval so a channel someone cannot see never appears in their answer. Advidi, for example, runs it that way: Unblocked is the MCP inside Claude and ChatGPT for its engineers, and its OpenClaw operations bot queries the same server. Its CTO put the reason plainly:

> Unblocked combines all of the tools we use into one product, one single MCP. And the search is efficient: the context it gathers is relevant and recent. I haven't found another tool that does that as effectively as Unblocked does.
>
> — Jorden van Breemen, CTO, Advidi


That permission layer was the part he singled out. A conversation from a channel only some people can see cannot be looped into someone else's conversation, though both query the same server.

## Five separate MCPs or one MCP: how do they compare on cost and upkeep?

On every axis a platform team gets paged about, the single server is cheaper, because the counts stop scaling with agents times sources. The MCP roadmap's March 2026 enterprise list, audit trails, SSO-integrated auth, gateway behavior and configuration portability, is the column this table fills in ([MCP roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/), 2026).

| Axis | Five separate source MCPs | One MCP in front of the sources |
| --- | --- | --- |
| Tokens per call | Tool definitions for every server on every turn; about 55,000 for a typical five-server set, per Anthropic's docs | Two tool definitions; 42% fewer total tokens in Unblocked's A/B |
| Auth flows per developer | Five, repeated for each agent that keeps its own token store | One OAuth sign-in per agent, or one team token |
| Permission model | Each server enforces its own; the agent merges results with no cross-source check | Enforced once at retrieval, scoped to the asker across all sources |
| Freshness | Whatever the source returns, including the 2023 page | Conflicts resolved toward the newest grounded decision, with citations |
| Who maintains it | Every developer, on every laptop, for every agent | The platform team, in one place, once |


The limit of the right-hand column is that it does not write. A ticket still gets filed through the Jira server. [Our MCP server roundup](https://getunblocked.com/blog/best-mcp-servers-for-engineering-teams-compared/) groups the per-tool servers that stay in the stack alongside it.

## Frequently asked questions

### Does a single context MCP replace the GitHub, Jira and Slack servers?

For reads, mostly; for writes, no. Questions about what was decided, why a service exists, or which PR changed a behaviour get a better answer from the reconciled server than from three raw searches, and cost fewer tokens. Filing a ticket, posting a message or opening a PR still goes through the vendor server, so keep those installed with write scope and tool search on.

### Can Devin use OAuth instead of a team token?

Yes. Devin supports OAuth for remote servers through its Connect button, and providers that need a pre-registered app take a client ID, secret and Devin's callback URL on their redirect allowlist ([Devin docs](https://docs.devin.ai/work-with-devin/mcp), living docs). Unblocked's docs note that custom clients failing with `invalid_redirect_uri` need that callback allowed. A team token scoped to the sources Devin needs is the shorter path.

### Will Codex and Claude Code get the same answer from the same server?

They get the same retrieved context: same index, same permission filter, same synthesized, cited response to the same question. What each model then does with it differs, which is the point. The variable you remove is the context; the one you keep is the agent.

### Does the 2026 MCP roadmap change any of this setup?

Not the registration. The maintainers say no new official transports will be added this cycle and that the existing transport will evolve so servers can scale horizontally without holding state, with a `.well-known` metadata format for discovery ([MCP roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/), 2026). Anthropic's 2026 Agentic Coding Trends Report covers multi-agent coordination alongside its eight trends ([Anthropic](https://resources.anthropic.com/2026-agentic-coding-trends-report), 2026). More agents per developer means more of the multiplication this page started from.

## What to install first: one MCP, then the source servers

Install the shared context server before you install another source server. Run `claude mcp add -s user --transport http unblocked https://getunblocked.com/api/mcpsse` on one laptop, add the two-line `[mcp_servers.unblocked]` table to Codex, and hand Devin the same URL over HTTP with a team token. Ask each agent the same "why" question and compare the three answers; they should cite the same PR and the same thread. Then move the entry into `managed-mcp.json` so new laptops get it without a setup doc. Keep GitHub and Jira for writes, scoped and read-only where possible. What you have at the end is one MCP for the whole team, with institutional memory that every agent reads the same way, from the context engine for engineering.