An intern asks the HR assistant for salary bands, and the HR system never finds out an intern asked. It sees svc-assistant, the one integration account the tool server signs in with. It’s the shared integration user problem with a model in front of it.
Most tool servers start out wired this way. Every request from every person reaches the backend as that account. Whatever permission model the backend spent years building never gets consulted, because from where it sits there’s only one caller, and that caller is allowed to do a lot.
In the tool server post I had a gateway hold one narrow credential per server. That’s still the floor. This post goes past it and carries the person.
One account gives everyone the same reach
Maplethorpe Group is a company I’ve invented to walk through this. Its HR assistant sits on a tool server, and the server talks to the HR system as svc-assistant, which can read compensation data company-wide because some manager, somewhere, will need any given slice of it.
The intern types “salary bands for my team.” The model calls get_salary_bands. The tool has no idea who is asking, so it either returns everything or trusts a team argument the model filled in. The intern gets the whole company’s bands, and the audit log records that svc-assistant read them.
You can patch this inside the tool server by passing a user id along and filtering results in code. I think that’s the wrong place for it. You end up with a second copy of the HR system’s permission rules, written by people who don’t own them, and it drifts the first time HR changes a role.
What the June spec revision settles
The Model Context Protocol got OAuth in its 2025-03-26 revision. The 2025-06-18 revision tightened the roles: a tool server is an OAuth resource server, the client has to name the server it wants a token for using a resource indicator (RFC 8707), and the server has to reject any token that wasn’t issued for it.
So the server finally knows who is calling. The open question is what it does next, when it turns around and calls the backend.
The tempting move is to forward the user’s token. The spec forbids it, and I agree with the spec. A token minted for the tool server would now be accepted by the HR API too, which means the HR API can’t tell a call that came through your server from one made by anything else that got hold of the token. Audience stops meaning anything.
OAuth 2.0 Token Exchange (RFC 8693) is the piece that fits. The tool server hands the authorization server the token it received and asks for a new one, same subject, aimed at the backend.
The token at each hop
This is the Maplethorpe call again, hop by hop, with the claims each party checks.
1. Agent client -> authorization server (authorization code flow, user signs in)
resource = https://hr-tools.maplethorpe.example/mcp
scope = comp.read
2. Authorization server -> agent client: access token A
sub = u-4821 (the intern)
aud = https://hr-tools.maplethorpe.example/mcp
scope = comp.read
exp = now + 10 min
3. Agent client -> tool server: tools/call get_salary_bands
Authorization: Bearer <A>
tool server verifies signature, iss, exp
tool server verifies aud is its own URL (mismatch: 401, stop)
tool server verifies scope covers this tool (missing: 403, stop)
4. Tool server -> authorization server: POST /token
grant_type = urn:ietf:params:oauth:grant-type:token-exchange
subject_token = <A>
subject_token_type = urn:ietf:params:oauth:token-type:access_token
resource = https://hr-api.maplethorpe.example
scope = bands.read
client credentials = hr-tools (the tool server's own identity)
5. Authorization server -> tool server: access token B
sub = u-4821
aud = https://hr-api.maplethorpe.example
scope = bands.read
act = {"sub": "hr-tools"}
exp = now + 5 min
6. Tool server -> HR API: GET /salary-bands
Authorization: Bearer <B>
HR API applies u-4821's HR role (6 rows)
7. Audit log entry, written by the HR API
user = u-4821 actor = hr-tools tool = get_salary_bands rows = 6
Two claims do most of the work. aud changes between token A and token B, so neither token is usable at the other hop. And act records that hr-tools is acting for the intern, so the log can name both.
The tool server no longer decides which rows the intern may see. It asks as the intern and takes what comes back.
Three ways to reach the backend
| Approach | Blast radius | Audit quality | Effort |
|---|---|---|---|
| Shared service account | Everything the account can touch, for every user | One name on every row | Lowest. One secret, no user sign-in |
| Token passthrough | The user’s rights, but one token now works at two services | Real user, no record of the software that acted | Low, and prohibited by the 2025-06-18 spec |
| Per-user exchange | The user’s rights at one backend, for a few minutes | Real user plus the acting server, logged by the system that owns the data | Highest. Exchange support, backend token validation, an exchange policy |
Work that lands on three teams
It isn’t free, and the work doesn’t sit with one group.
Your authorization server has to support token exchange, and someone has to write the rule that says hr-tools may trade tokens for the HR API and for nothing else. Without that rule you’ve built a machine that upgrades any token into any other.
The backend has to accept bearer tokens from that issuer and map sub to one of its own users. Plenty of internal systems only take an API key. For those I’d keep the shared account, cut its grants to the minimum, and write the user id into the tool server’s log. That’s weaker, and the design doc should say so.
There’s also an extra round trip per call. Cache token B per user and backend until shortly before it expires and the cost mostly disappears.
A side benefit: this bounds what a poisoned tool result can do. I wrote about tool descriptions as an attack path and about scoping an agent’s database role; per-user tokens apply the same idea one layer up. An injected instruction can only reach what the person in the chat could already reach.
The intern asks again
Same question, same tool. The HR API sees u-4821, looks up an intern on the platform team, and returns 6 rows. The log line names the intern and the server that acted for them.
I’ve written about testing an agent as different users. For a tool server, the column to read afterward is the user column in the backend’s audit log. If it says svc-assistant, the backend never knew who asked.