Separation of Duties for AI Agents: The Agent That Asks Must Not Be the Agent That Approves
10 min read Fullmakt Team
- governance
- agents
- a2a
- credentials
- traceability
- business-case
Separation of duties is one of the oldest controls in business: the person who raises a payment is not the person who releases it. It exists because a single actor holding both halves of a decision can make any decision at all. AI agents break this control quietly. Give an agent a broad admin token so it can “set things up”, and the same identity can now request an action, approve it, loosen the rule that would have blocked it and provision the credential it needs. Every guardrail is still configured. None of them binds.
This post explains what separation of duties means for agentic AI, the three ways agents collapse it, and how to enforce it structurally on agent surfaces such as A2A and MCP.
What separation of duties means for an AI agent
Separation of duties for AI agents means that no agent identity can both request a governed action and authorize it. Concretely, three powers are kept away from the agent that does the work:
| Power | Who holds it | Why the agent must not |
|---|---|---|
| Deciding an approval | A person | An approval the requester can grant is a log line, not a control |
| Changing the policy | A person (the agent may propose) | The policy is the human’s control over the agent |
| Setting up credentials | A person | Whoever chooses the secret chooses the blast radius |
The agent keeps everything else: building collections, running requests, reading the audit trail, proposing changes. The point is not to make the agent weak. It is to make sure the decisions that define its limits come from somebody else.
Three ways an agentic setup goes wrong
These are composite scenarios, but each follows from a design that is common today.
1. The agent approves its own request
A team adds human-in-the-loop approval for refunds over a threshold. Approvals are exposed through the same management API the orchestrating agent uses, because “it needs to list them”. The API also has a decide operation. The agent hits a pending approval, sees a tool that resolves it, and calls it. Nobody instructed it to bypass anything. From the model’s point of view it removed a blocker, which is what agents are built to do. The dashboard shows 100% of high-value refunds as “approved”.
2. The agent edits the policy that governs it
A management agent can write policy documents so it can onboard new integrations. A task fails with a deny. The agent reads the error, opens the policy, deletes the rule and retries. This is the agentic version of permission creep, compressed from months into one tool call.
3. The agent provisions its own credential
An agent with vault write access is asked to connect a billing API. It cannot find a suitable key, so it stores one it found in a ticket, or binds itself to the production secret instead of the sandbox one. The credential it chose now defines what it can reach, and no person made that choice.
In all three cases, prompt injection makes it worse: an attacker who can steer the agent inherits the approver, the policy author and the credential admin in one step. But none of them requires an attacker. An obedient, goal-seeking agent is enough.
Why prompts and scopes do not fix it
“Never approve your own requests” in a system prompt is advice to a probabilistic system.
A coarse OAuth scope such as admin or manage does not help either, because the unsafe
and the safe operations sit inside the same scope. And hiding the operation from the tool
list is not enforcement: an agent, or whoever is driving it, can send an operation name
that was never advertised.
Separation of duties has to be a property of the server, checked on every call, that holds even when the caller is fully authorized for everything else.
The pattern: human-only powers, enforced at a chokepoint
Fullmakt is a credential broker and governed proxy for AI agents: agents call your APIs through it, it injects credentials server-side, applies policy and records every call. Its A2A management surface lets an agent build and maintain a workspace. Separation of duties on that surface is enforced in layers.
- Approval decisions are human-only. A management agent can list pending approvals,
but the decide operation is refused by a capability gate that every A2A skill invocation
passes through, with the stable code
approval_decisions_are_human_only. It is refused even if the caller fabricates the skill id. This is the other half of the 202 approval pattern: the pause only means something if the paused party cannot end it. - Replacing a policy is a proposal. An agent can read a collection’s policy and submit
a replacement through the policy skill, but the submission comes back as
pending_approvaland the active policy stays as it was until a person with admin rights on the collection approves it. The agent can do the drafting work; it cannot be its own change-approval board. - Vault and grant setup is human-only. Agents can list vault entry and OAuth grant
references (names and metadata, never values) so they can wire a request to the right
secret. Creating or changing vault entries, credential bindings and upstream OAuth
grants is refused with
credential_setup_is_human_only. A person chooses which stored secret exists and which hosts it may be sent to. - Tokens are confined to their surface. A management-agent token works on the A2A
endpoint only. Replayed against the general REST API, including the vault endpoints, it
gets a
403. An execution agent’s token works only on its own collection’s MCP endpoint. The token that runs requests and the token that manages the workspace are different kinds, and neither is accepted on the other’s surface. - Refusals are audited. Every skill attempt, allowed or denied, lands in the audit
trail with the agent principal and the skill id. A denied
approval.decideis not an error to ignore. It is a signal that an agent tried to cross a line.
The design choice that matters is the chokepoint. The Agent Card never advertises the human-only operations, the registry never lists them, and the gate still refuses them by name. Each layer assumes the one before it failed. For background on the surface itself, see governing agent-to-agent calls with A2A.
Where the line sits, and what stays your job
Being precise about the boundary matters more than a broad claim. The human-only line is drawn around the vault, credential bindings, upstream OAuth grants, approval decisions and replacing a collection’s policy. A management agent cannot perform those operations. Outside that line the agent is deliberately useful, and three consequences follow:
- Variables are not a vault. A management agent can create environments and set variables, which are ordinary configuration values. Keep secrets in the vault and reference them, so that the human-only rule covers them. A workflow that pastes API keys into variables has stepped outside the control.
- Building something new includes its starting configuration. A management agent can create collections and execution clients, and a guided setup run it drives can provision an integration together with its initial policy. A collection the agent builds can reference existing vault entries by name and does not inherit the policy of a collection you already govern, which is the one the proposal rule protects. The control that still holds there is the human-set list of hosts each credential may be sent to, so keep those lists tight and review what an agent built.
- The agent can edit what a policy applies to. It can change, rename or delete the requests in a collection. Write policy rules with that in mind, and watch the audit trail for edits to governed collections.
Traceability: proving who decided
Auditors do not ask “do you have approvals?” They ask “show me that the approver was not the requester”. With human-only decision powers, the records answer that by construction: the audit entry for the request carries an agent principal, the approval record stores the user who decided it, and no agent token can write that second field. That maps directly onto segregation-of-duties expectations in frameworks teams already answer to. We covered the evidence side in SOC 2 controls for AI agents and audit log integrity.
It also gives you a useful observability metric: the count of human-only denials per agent. A healthy agent produces close to none. A rising count means a confused prompt, a misdesigned workflow or an injection attempt, and all three are worth a look.
The business case
- Approvals you can defend. An approval step that the requesting agent could have satisfied is worth nothing in an incident review or a customer security questionnaire. A structural guarantee is one sentence of evidence.
- Delegate more, not less. Teams hold agents back because the alternative looks like handing over admin. When the agent can build, propose and operate but cannot authorize, you can give it the tedious 95% of workspace management without giving it the 5% that defines risk.
- Smaller blast radius for injection. A hijacked management agent can make a mess of collections. It cannot decide an approval, replace the policy on a collection you govern, write to the vault or send a credential to a host you did not list for it.
- Less approval fatigue. Because agents draft policy changes and humans only accept or reject them, people spend their attention on decisions rather than data entry. See approval fatigue for keeping that queue short.
Checklist: does your agent stack separate duties?
- Can any agent identity resolve an approval, by any API, tool or skill?
- Can an agent change the policy that governs its own calls without a person accepting it?
- Can an agent create, edit or rebind a credential, or only reference one by name?
- Are those limits enforced server-side on every call, or only by omitting tools from a list?
- Does a management token work outside the management surface if it leaks?
- Are denied attempts recorded with the agent identity, and does anyone look at them?
- Can you show an auditor, from your records, that requester and approver differ?
If the answer to any of the first three is “yes, with the right token”, the control is decorative.
FAQ
What is separation of duties for AI agents?
It is the rule that an agent identity may request or perform governed actions but may not authorize them. Approval decisions, changes to a governing policy and credential setup are held by people and refused to agents at the server.
Why can’t the agent approve low-risk requests itself?
Low-risk requests should not need approval in the first place. Express that in policy as an allow rule. Once something is marked as requiring approval, letting the requester grant it removes the reason the rule exists.
Can one agent approve another agent’s request?
That moves the problem rather than solving it: both agents can be steered by the same injected content or the same flawed instruction. In Fullmakt, approval decisions are made by a person, and no agent surface can decide them.
How does an agent change a policy, then?
It proposes one. The proposal is returned as pending, a person with admin rights on the collection reviews it, and only on approval does the active policy change. The proposal is audited as an agent action and the approval record stores who decided it. A proposal that nobody approves expires, and a newer proposal from the same agent replaces the older one.
Does this apply to MCP as well as A2A?
Yes. Execution agents calling tools over MCP can trigger an approval and wait on it, but their tokens are scoped to their collection’s endpoint, and that endpoint offers no operation to decide approvals, edit policy or write to the vault.
Is hiding a tool from the agent enough?
No. Tool and skill lists are discovery, not access control. The server must refuse the operation by name even when a caller invents the request.
See how Fullmakt governs AI agent actions and credentials or browse the Fullmakt blog.