Real-time authorization, bound to the mandate.
The agent holds a card scoped to its own spend mandate, for the ad-hoc purchases operations always ends up routing to someone's personal card: a subscription renewal, a travel booking, a one-off vendor charge. Every attempt to use it is evaluated in real time by CodeSpar's own authorizer, running live inside a PCI-scoped cardholder data environment on AWS — checking the merchant, the amount and the mandate's cap the instant the charge is tried.
Every attempt gets a real decision. No attempt moves a real dollar — yet.
One card authorization attempt, end to end: the authorizer checks the merchant, the amount and the mandate's cap the instant the charge is tried, inside CodeSpar's own PCI-scoped cardholder data environment on AWS. It records what it would do. Observe mode stops there — the decision is logged, not executed, and no money moves.
- The mandate's cap, merchant category and validity window are checked in real time, on AWS, inside CodeSpar's PCI-scoped environment
- The authorizer records what it would have done — approve or decline — against the mandate
- Observe mode never moves money; the decision is logged, not executed
Renew the analytics subscription under the ops mandate.
Attempting a $340 charge to SubscriptionCo. The authorizer is evaluating it against the mandate now — in observe mode, it will decide but will not execute the charge.
The conversation is the easy part.
"Governance" on a corporate card today means a shared number, a spreadsheet of who's allowed to use it, and a statement review three weeks after the damage is done. An agent making ad-hoc purchases makes that worse, not better — there is no human in the loop to notice a bad charge before it clears.
One shared card number, handed to whichever agent needs to buy something
Each purchase attempt runs against the agent's own signed mandate, cap and merchant rules
Approvals happen after the statement arrives, weeks later
The authorizer evaluates the charge in real time, the moment it's attempted
No record of why a charge was allowed, only that it happened
Every attempt is logged with the mandate, the decision and the reasoning behind it
"Governance" means hoping nobody swipes past the limit
The decision logic runs live, in the open, checked against the mandate every time
A real authorizer, running in observe mode, on purpose.
codespar_card_authorize evaluates every attempted charge against the signed mandate — cap, merchant category, validity window — in real time, inside CodeSpar's own PCI-scoped cardholder data environment on AWS. codespar_ledger seals the attempt and the decision to the mandate that governed it, the same governance primitive that gates every other rail the agent touches.
Agent tries to charge the mandate's card
codespar_card_authorizeMandate, cap and MCC checked live
CodeSpar CDE · AWSApprove or decline computed
Decision sealed in real time
codespar_ledgerAttempt + decision sealed to mandate
Audit ledgerThe card lives inside CodeSpar's own PCI-scoped cardholder data environment on AWS, not a third-party issuer's black box. When the agent attempts a charge, the authorizer evaluates it in real time against the tenant's signed mandate — the spend cap, merchant category and validity window — the same governance primitive that gates every other rail the agent touches. Full settlement follows as the authorizer moves from deciding to executing.
A few lines. The whole loop.
const session = await codespar.sessions.create(); const attempt = await session.execute("codespar_card_authorize", { merchant: "SubscriptionCo", mcc: "5817", amount: 340.00, currency: "USD", mandate: "cm_ops", }); // attempt.decision: "approve" | "decline" // attempt.executed: false — observe mode never moves money console.log(attempt.decision, attempt.reason); await session.execute("codespar_ledger", { record: "card_authorization", attempt, });
codespar_card_authorizeEvaluates a card charge attempt against the mandate in real time, inside CodeSpar's PCI-scoped cardholder data environment. Runs in observe mode today — it decides, it does not execute.
codespar_ledgerLogs every authorization attempt and its decision, sealed to the mandate that governed it.
codespar_mandateDefines the spend cap, merchant rules and validity window the authorizer checks every attempt against.
Ship it this afternoon.
Open the sandbox, point a session at your providers, and run the whole loop against real rails in minutes — not the quarter it takes to build it by hand.