MCP Stateless Payments and Policy Enforcement: How Paitify Closes the Authorization Gap
The Model Context Protocol keeps moving toward a simpler mental model: a stateless server, a well-typed tool call, and a client that doesn't need to remember anything between requests. That simplicity is the whole point — it's what let the MCP ecosystem grow to thousands of public servers without every integration reinventing session handling from scratch. It's also, increasingly, the substrate a lot of real money moves over. Stripe MCP can create a charge. Marqeta MCP can provision a card. Coinbase's x402 protocol lets an HTTP response itself carry a payment requirement, settled machine-to-machine with no human in the loop at all. None of that is speculative — it's shipping today, and agent frameworks are wiring into it as fast as it appears.
Part of what's driving that is x402 itself: repurposing the long-dormant HTTP 402 "Payment Required" status so a server's response can carry a machine-readable payment requirement, settled by the client without a human clicking "approve" anywhere in the loop. That's a genuinely useful primitive for agent-to-agent commerce — but notice what it doesn't do. x402 standardizes how a payment gets requested and settled between two machines. It has no opinion on whether the agent making that payment should have been allowed to, for this amount, to this counterparty, at this point in its budget. That question sits one layer up, and it's the same question regardless of whether the payment rail underneath is x402, a card network, or a bank transfer.
Stateless is the right architecture for a protocol. It is not, by itself, an authorization model. And the gap between those two things is where this post lives.
What "authenticated" actually proves
Every one of the payment-capable MCP servers above gets authentication right. OAuth token binding, scoped credentials, signed requests — the client calling charge or create_card is provably who it claims to be, and provably permitted to invoke that tool at all. That's real, necessary work, and it's not the part that's missing.
What it doesn't do is answer a second, independent question: should this specific call, for this amount, to this merchant, right now, actually be allowed? A credential scoped to call a payment tool is exactly as valid whether the agent requests $12 or $12,000, once or a thousand times in the same minute. OAuth scope is a door; it doesn't know or care what's about to walk through it. Stripe MCP, Marqeta MCP, and x402 are all, by design, silent on this — it isn't a flaw in any of them, it's simply a layer none of them were built to own. Someone has to own it, and today that someone is usually nobody: the gap gets closed by an agent's system prompt, if it's closed at all, which is the same fragile pattern we've written about before.
Policy before the tool call, not after
Paitify's answer is structural rather than clever: a policy check runs before the payment tool executes, not as a post-hoc reconciliation of what an agent claims it did. The shape of that check is deliberately narrow and MCP-native — five tools, each doing one job:
authorize_spend— evaluate a proposed transaction against the agent's active policy and return a decisionget_authorization_status— check the live state of a specific authorization before acting on itcapture_spend— commit a reservation once the downstream payment actually clearscancel_spend— release a reservation that never completedget_remaining_budget— check headroom before even attempting a spend
The policy being evaluated is the same one a REST caller would hit at /v1/integration/authorize — MCP is a different door into the same enforcement layer, never a looser one. Per-transaction caps, daily and monthly budgets, merchant and MCC allowlists, velocity limits, and a threshold above which a human has to sign off before anything clears: all of it runs against the request itself, before the agent is allowed to proceed to the actual charge, invoice, or payout.
That ordering — policy, then payment, never the reverse — is the entire structural claim of this post. Everything below is the mechanics of how it holds up under stateless, agent-driven traffic.
Inside the enforcement layer
Three design choices make the "check before the call" model work without reintroducing the statefulness MCP is trying to get away from:
JWT-signed approvals, verifiable without a callback. A successful authorize_spend call returns a short-lived, signed JWT — a bearer credential a downstream relying party can validate against Paitify's public JWKS endpoint (/.well-known/jwks.json) without an additional network round-trip back to Paitify. That's what keeps the check compatible with a stateless MCP server: the proof of authorization travels with the request instead of requiring the payment rail to maintain a session.
That said, signature validity is not the same as authorization validity. The token proves the decision was legitimately issued; it says nothing about whether that decision still holds right now. A human can deny a pending approval, or the transaction can be cancelled, in the window between when the token was issued and when it's actually used — cancel and reverse don't revoke the token itself. Any relying party has to re-check live state via get_authorization_status immediately before honoring a token, not just verify the signature and move on. We go deeper on this trust boundary, and why it's easy to get subtly wrong, in our integration guide.
A hash-chained audit log, independent of what the agent reports. Every authorize_spend call — approved, declined, or escalated to a human — writes an immutable entry into an append-only log where each entry's hash is derived from the previous one. That gives you tamper-evidence for free: altering or deleting a historical entry breaks every hash after it, which is a structurally different guarantee than "we have logs and haven't checked them." For a stateless protocol with no session to fall back on, this is what turns "the agent said it charged the right amount" into something a human can independently verify after the fact — a theme we go deeper on in Designing Auditable Guardrails for Autonomous Spend.
A state machine, not a single decision field. A request that starts AUTHORIZED can move to CAPTURED, CANCELLED, or REVERSED; a REQUIRES_APPROVAL request can resolve to DECLINED_BY_HUMAN well after the original call. Any system built on top of this — including the MCP tool layer itself — has to branch on the transaction's current state, not on whatever was decided at creation time. That's also why get_authorization_status exists as its own tool rather than being folded into authorize_spend: state changes after the initial call, and a relying party needs a cheap way to ask "is this still good?" without re-running the whole authorization.
Put together, an MCP client integration looks like this: call authorize_spend before the payment tool, check the returned state, only proceed to the actual charge on AUTHORIZED or CAPTURED, and re-verify with get_authorization_status if there's any meaningful delay — a queued job, a human-approval wait, a retry — between the two calls. As a raw JSON-RPC exchange against https://connect.paitify.io/mcp, the first half of that looks like this:
// Request
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "authorize_spend",
"arguments": {
"agentId": "agt_9f2c",
"amount": 42.00,
"currency": "USD",
"merchantName": "AWS",
"mccCode": "7372",
"idempotencyKey": "task-4471-charge"
}
}
}
// Response
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"authorizationId": "auth_7bd1",
"state": "AUTHORIZED",
"jwtToken": "eyJhbGciOi...",
"reasonCode": null
}
}
Nothing about that exchange requires the MCP server to remember this agent's prior calls — the whole decision is derivable from the request itself plus server-side policy state, which is exactly the property a stateless transport needs from anything sitting behind it. The jwtToken in the response is what a downstream relying party checks against the JWKS endpoint; the authorizationId is what it re-checks via get_authorization_status if time has passed since this call was made.
Where this sits relative to the rest of the field
A handful of other products touch some part of this problem, but from what's publicly known about each, none occupy quite the same spot:
- Arcade solves multi-user auth for agent tool calls well — proving which human an agent is acting on behalf of — but that's an identity question, not a spend-policy one; it doesn't evaluate whether a specific transaction amount or merchant should be allowed.
- Locus is ledger-based: it tracks and reconciles fund movement after the fact, which means adopting it means actually moving money through its rails, not just gating a decision before a call elsewhere.
- Portal26 offers token/usage budgets for agents, which caps API consumption but doesn't extend into merchant allowlists, MCC-level rules, or human-approval thresholds tied to real transaction risk.
- Formance supports genuinely sophisticated nested budgets, but it's ledger-heavy infrastructure — a bigger commitment than "add a policy check in front of tool calls we're already making."
Paitify's bet is narrower on purpose: it never moves money and isn't a ledger or a payment rail. It's the governance layer that decides whether a payment rail — whichever one you're already using — should be allowed to run for this specific call. That scope keeps the integration to "one API call before the payment tool," which is what makes it viable to bolt onto an existing MCP-based agent stack rather than requiring a rebuild around a new ledger.
Where this shows up in practice
A few shapes this takes in real agent deployments:
- A CrewAI crew with a shared budget. Multiple agents in a crew — a researcher, a buyer, an approver — can each hold a scoped policy (different merchant allowlists, different limits) rather than sharing one broad grant that any compromised or misbehaving crew member could exhaust.
- A LangChain procurement agent restricted to its MCC. An agent authorized to purchase SaaS tooling gets a policy scoped to the relevant MCC codes (computer services, software) — a prompt that says "only buy software" is advice; an MCC allowlist is enforced.
- A Stripe MCP shopping agent with a per-transaction ceiling and a human backstop. Routine purchases under a threshold clear automatically; anything larger holds for
REQUIRES_APPROVALand a human review, rather than trusting the agent's own judgment about what counts as "reasonable."
In every case, the pattern is identical: the policy check happens in the orchestration layer wrapping the tool call, not inside the payment MCP server and not inside the agent's own reasoning. That's also what makes velocity limits meaningful in a way a static allowlist alone isn't — a single agent instance retrying a failed task, or a compromised one probing for what it can get away with, hits a rate ceiling on rapid repeated authorization attempts before it can turn a bug or an exploit into a large bill. Multi-agent deployments make this more, not less, important: without per-agent policy scoping, one agent's blast radius is every other agent's budget too.
Getting started
None of this requires committing to a paid plan first. The Free tier includes real policy enforcement and a 7-day audit log — enough to wire authorize_spend in front of a test agent's payment tool calls before deciding how far to take it. Watch the 90-second demo to see an agent get auto-approved and then stopped mid-transaction, or get started free and read the full API and MCP reference for every tool and endpoint used here.