Guide // MandateGuard
How do MCP tools let an agent check its spending mandate?
By the Ingenious AI team · Published 2026-11-14 · Reviewed 2026-11-14
▸ Run the free live demo See pricing
Free covers 1 agent and 1 policy with the full authorize flow, signed receipts and the approval inbox — no card required to start.
Short answer
MCP tools put the spending-policy check inside the agent's own tool loop. MandateGuard's MCP server (POST /mcp) offers mandate.preview so an agent can check a proposed spend against its policy before committing, and mandate.get_receipt so it can fetch the signed record afterwards — plus the intent family for shared mandates: register, get, list, authorize, event and verify_receipt. The tools run on the same engine and write to the same receipt chain as the REST API, so an MCP-native agent and an API-integrated agent reconcile into one ledger. MCP access is part of the Pro and Team feature set.
What are the MandateGuard MCP tools?
MandateGuard's MCP server exposes the policy layer as tools an agent can call natively: mandate.preview to check a proposed spend against the policy, and mandate.get_receipt to fetch receipt records. The intent service adds its own tool family (register, get, list, authorize, event, verify receipt). MCP changes the transport, not the authority: decisions still come from the same engine and land in the same hash-chained ledger as API decisions.
Why MCP for a policy layer
Agents increasingly live inside frameworks that discover capabilities as tools. A spending check that exists only as a REST endpoint requires bespoke glue in every framework; the same check exposed over the Model Context Protocol becomes a tool the agent can find and call in its normal planning loop. That placement matters behaviourally: when checking the mandate is a first-class tool — as natural as the search or checkout tool — agents check early, while the purchase is still a plan. MandateGuard's MCP server is therefore not a novelty transport. It is the policy layer showing up in the room where agent decisions are actually made, with tools for previewing a spend and fetching receipts.
The two core tools
mandate.preview answers the pre-spend question: given this vendor and amount, what would the policy say? Agents use it while composing a plan, so an over-cap or unlisted purchase is discovered before checkout machinery engages. mandate.get_receipt retrieves receipt records, letting an agent cite the chain entry for a completed decision — useful when a downstream step, a report or a human asks for proof of what was authorised. Together they close a loop that REST-only integrations often leave open: the agent can both ask permission in its native idiom and produce the evidence afterwards, without a human translating between systems.
Same engine, same ledger
The critical design fact is that MCP decisions are not a parallel universe. The tools call the same policy engine that serves the REST authorize endpoint, so caps, allowlists, thresholds and frozen state apply identically, and outcomes land in the same hash-chained receipt history your inbox and audits already read. That uniformity is what makes mixed fleets manageable: one agent integrated over REST and another over MCP still reconcile into one ledger per workspace, one vendor trust table and one chain to verify. When you evaluate any MCP policy tool — MandateGuard's included — the first question should be whether it shares state with the rest of the control plane or forks it.
The intent tool family
For shared mandates, the MCP surface extends to the interoperable intent service: intent.register creates an intent, intent.get and intent.list read state, intent.authorize runs an authorisation against a registered intent with its cumulative budget, intent.event appends post-transaction events such as refunds, and intent.verify_receipt performs the cross-party receipt check. An agent working inside an intent — buying against a merchant-scoped mandate an issuer registered — can therefore operate the whole lifecycle through tools, while role-scoped keys keep merchant-side participants read-only. The registry UI shows the same intents, so humans and agents are never looking at different versions of the mandate.
Integration habits that make MCP checks real
Tool availability is not tool use. Make the preview call a designed step in the agent's purchase workflow, not an optional flourish: the buying procedure should name it, and the completion criteria for a purchase task should include the decision outcome. Have the agent record the receipt reference in its own output, so human reviewers can jump from a task summary to the chain entry. And test the refusal path with the same seriousness as the success path — ask the agent to buy something over cap in a test workspace and confirm it previews, stops, and explains, rather than improvising around the answer. MCP makes the check easy to call; your workflow design makes it called.
Plans and scope
The MCP server is part of MandateGuard's paid depth on Pro and Team, alongside multiple agents and policies, vendor trust, duplicate detection, the kill-switch and evidence export. Scope discipline matters here too: the MCP tools operate the spending-policy plane only. They do not issue agent identity credentials (that is Agent Passport's product) and they do not publish reputation scores (vendor trust stays inside your workspace). Keeping the tool surface narrow is a security property: an agent holding MandateGuard tools holds the ability to ask and to prove, while the abilities to approve, to unfreeze and to change policy remain with humans holding workspace credentials.
Five actions to take now
- Expose mandate.preview to the agent before any spend action
- Have the agent fetch and quote receipts with mandate.get_receipt after decisions
- Keep the MCP path behind the same policy — no side-channel allowances
- Test a preview that returns a denial and confirm the agent stops
- On paid plans, use the intent MCP tools for shared mandates
Worked example: preview-first agent behaviour
An agent framework team connects MandateGuard's MCP server and gives their research agent two habits: preview before purchase, receipt after. In the first month the agent previews 143 spends. Eleven previews return what would have been denials — six over the approval threshold, handled by waiting for tokens; three over the per-task cap, replanned smaller; two from an unlisted vendor, rerouted to the allowlisted provider.
Because previews exercise the same engine, those eleven course-corrections appear in the workspace's decision history, and the team's month-end review reads like a flight recorder: what the agent wanted, what the mandate said, and what actually got bought — 132 purchases, every one preceded by a policy check the agent performed itself.
Frequently asked questions
Is MCP available on the free plan?
The MCP server is part of the paid feature set described for Pro and Team. The REST authorize flow covers the free plan's single agent fully.
Does preview spend any budget?
Preview is the policy check surface for agents; decisions taken through the authorize flow are what move the day totals and receipts for actual spends. Follow the tool responses in your integration.
Can MCP tools bypass the inbox?
No. Approval states still resolve through humans; MCP does not mint approvals.
Do intent tools share state with the API?
Yes — intents registered via MCP are the same objects the API and registry UI show, with the same budgets and event chain.
Which agents can use MCP?
Any client that speaks the Model Context Protocol can call the tools; MandateGuard's server is a standard POST /mcp endpoint.
Keep reading
- How do you integrate an authorize check before an agent spends?
- What is an interoperable intent service for agent mandates?
- What is an AP2-style intent mandate for agent payments?
Put the policy in force: spend envelopes · intent registry · approval inbox · how the proof works · all MandateGuard guides