A spending firewall and permission layer for AI agents. Give your agent a signed budget it can't exceed — even if it gets prompt-injected — and get a tamper-proof receipt for everything it does.
Zero dependencies · TypeScript · Ed25519 + W3C DIDs · works with MCP, LangChain, or any tool-calling agent.
The problem
Verify an AI agent's payment authority: signed mandates, allowlists, and tamper-proof receipts.
2026-11-07
ดาว
—
เครื่องมือ
—
อัปไทม์
—
Your AI agent can hold a wallet and call payment APIs. That's useful — and dangerous. One prompt injection from a poisoned web page, one hallucination, one bug, and your agent pays the wrong party. This is a documented, actively-exploited failure mode: agents tricked into wiring funds to attacker-controlled accounts.
What Vantic does
You issue your agent a signed mandate — a budget, a per-transaction cap, allowed actions, and an allowlist of who it may pay — and wrap its money-moving calls (purchase, subscribe, transfer, pay-per-use, payout, refund — any action that moves value). From then on, an out-of-scope payment is impossible: the check runs before the money-moving code, so even a fully compromised model can't execute it. Every allowed action emits a signed, tamper-proof receipt — a clean audit trail, and evidence if a charge is ever disputed.
Install
npm install @vantic/sdk
Protect your agent in ~5 lines
import { generateKeyPair, issueMandate, AgentWallet } from "@vantic/sdk";
const owner = generateKeyPair(); // you (the principal)
const agent = generateKeyPair(); // your autonomous agent
// Authorize the agent: what it may pay for, ≤ $200 each, ≤ $500/week, only these counterparties.
const mandate = issueMandate({
agent: agent.publicKey,
principal: owner.publicKey,
principalPrivateKeyPem: owner.privateKeyPem,
ttlSeconds: 7 * 24 * 3600,
scope: {
budget: { currency: "USD", amount: 50000, windowSeconds: 7 * 24 * 3600 }, // $500 / 7 days
maxPerTransaction: 20000, // $200
allowedActions: ["purchase", "subscribe"], // any money-moving action: transfer, payout, refund, …
allowedCounterparties: ["etsy.com", "*.shop.example"],
},
});
const wallet = new AgentWallet(mandate, agent.privateKeyPem);
// Your real payment call goes inside the executor. The guard runs FIRST;
// if the action is out of scope, the executor is never called.
await wallet.spend(
{ type: "purchase", counterparty: "etsy.com", amount: 4500, currency: "USD" },
async (action) => ({ outcome: "settled", result: await pay(action) }),
);
// A prompt-injected wallet.spend({ counterparty: "attacker.xyz", ... })
// throws GuardViolation — before any money moves.
Run npm run guard-demo to watch it block live attacker payments.
Already have a payment tool? Wrap it once.
For MCP / LangChain / function-calling agents, gate an existing tool without restructuring anything:
import { wrapMcpTool } from "@vantic/sdk";
const guardedPurchase = wrapMcpTool(purchaseTool, {
wallet,
toAction: (args) => ({ type: "purchase", counterparty: args.merchant, amount: args.amountCents, currency: args.currency }),
});
// Register `guardedPurchase` instead of `purchaseTool`. A blocked call comes back as a tool
// error the model can read and recover from; the real charge never fires.
Framework guides (OpenAI, LangChain, Vercel AI SDK, MCP, raw): docs/integrations.md.
What you get
Hard spending limits — per-transaction cap and a rolling budget window, enforced deterministically.
Counterparty allowlists — the agent can only pay who you allow (exact match or wildcard domains).
Prompt-injection protection — the mandate is enforced outside the model, so a compromised agent can't spend out of scope.
Tamper-proof receipts — a signed, hash-chained record of every action; verify offline; use as dispute evidence.
Standard identity — agents and owners are W3C did:key/did:web DIDs, and the owner→agent relationship is a W3C Verifiable Credential.
MCP server — npx vantic-mcp exposes verification tools to any MCP host.
Zero dependencies — Node's built-in crypto only. Ed25519 + SHA-256.
Agents and owners can be identified by bare keys (key:<x>) or by W3C did:key DIDs — interchangeable, both verify. generateKeyPair() returns both. DIDs resolve to standard DID documents offline (resolveDidKey), the same key can be published as did:web (buildDidWebDocument), and the owner→agent relationship is a portable W3C Verifiable Credential (issueSponsorCredential / verifySponsorCredential). See npm run identity-demo.
Develop
cd sdk
npm install
npm test # 39 tests
npm run demo # end-to-end walkthrough
Learn more
docs/integrations.md — add Vantic to OpenAI / LangChain / Vercel AI SDK / MCP / raw agents.
v0.1 — early, and honest about it. The code is production-quality (Ed25519 + SHA-256 + canonical JSON; did:key/did:web + Verifiable Credential identity; zero runtime dependencies), but it is not yet audited and the wire format isn't frozen.
ROADMAP.md — exactly what is and isn't hardened, and the path to v1.0.
SECURITY.md — how to report a vulnerability (please don't open a public issue).