Provides a governance and payment layer for AI agents, including budget enforcement, reputation scoring, and tamper-evident audit trails.
Also known as mnemopay/mnemopay-sdk, @mnemopay/sdk
- Stars
- 9
- Tools
- 14
- Downloads, 30 days
- —
- Latest version
- 1.4.1
- Last commit
- Nov 14, 2026
- License
- Apache-2.0
What is MnemoPay MCP?
MnemoPay provides a governance and payment layer for AI agents, including budget enforcement, reputation scoring, and tamper-evident audit trails. It exposes 14 tools, such as remember, recall, forget.
Summary generated from the project's README
About MnemoPay MCP server
MnemoPay provides a governance and payment layer designed for AI agents that perform consequential actions, such as moving money or modifying infrastructure. It functions as a middle layer between the agent runtime, like LangChain or CrewAI, and the payment rails, such as Stripe, Lightning, or Google AP2. This allows developers to define mission scopes through charters and enforce strict budget limits using FiscalGate.
The system includes tools for reputation scoring on a 300-850 scale and maintains a tamper-evident MerkleAudit chain for accountability. It is built to support compliance requirements, specifically providing audit bundles for EU AI Act Article 12. Developers can implement this locally via npm or PyPI, using TypeScript for advanced features like FiscalGate and Article 12. The SDK also supports swarm operations, enabling multiple agents to work in parallel under a single budget envelope and shared audit trail.
What you can do with it
- 1Enforce agent spending limitsA developer can set strict financial boundaries to ensure an autonomous agent does not exceed a specific budget during operations.
- 2Generate compliance audit trailsUsers can produce verifiable evidence of agent actions to meet specific regulatory requirements like the EU AI Act.
- 3Track agent reliabilityDevelopers can assign a numerical trust value to software agents based on their transaction history and behavior.
Written from the project's README. Every use case is checked against a quote from it.
How to install MnemoPay MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall MnemoPay MCP in Claude Code
$ claude mcp add --env 'MNEMOPAY_API_KEY=<YOUR_MNEMOPAY_API_KEY>' sdk -- npx -y @mnemopay/sdkInstall MnemoPay MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"sdk": {
"command": "npx",
"args": [
"-y",
"@mnemopay/sdk"
],
"env": {
"MNEMOPAY_API_KEY": "<YOUR_MNEMOPAY_API_KEY>"
}
}
}
}Install MnemoPay MCP in VS Code
.vscode/mcp.json
{
"servers": {
"sdk": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@mnemopay/sdk"
],
"env": {
"MNEMOPAY_API_KEY": "<YOUR_MNEMOPAY_API_KEY>"
}
}
}
}Install MnemoPay MCP in VS Code CLI
$ code --add-mcp '{"name":"sdk","type":"stdio","command":"npx","args":["-y","@mnemopay/sdk"],"env":{"MNEMOPAY_API_KEY":"<YOUR_MNEMOPAY_API_KEY>"}}'Install MnemoPay MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"sdk": {
"command": "npx",
"args": [
"-y",
"@mnemopay/sdk"
],
"env": {
"MNEMOPAY_API_KEY": "<YOUR_MNEMOPAY_API_KEY>"
}
}
}
}Install MnemoPay MCP in Codex
$ codex mcp add sdk --env 'MNEMOPAY_API_KEY=<YOUR_MNEMOPAY_API_KEY>' -- npx -y @mnemopay/sdkInstall MnemoPay MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.sdk] command = "npx" args = ["-y", "@mnemopay/sdk"] [mcp_servers.sdk.env] MNEMOPAY_API_KEY = "<YOUR_MNEMOPAY_API_KEY>"
Install MnemoPay MCP in Gemini CLI
$ gemini mcp add -s user -e 'MNEMOPAY_API_KEY=<YOUR_MNEMOPAY_API_KEY>' sdk npx -- -y @mnemopay/sdkInstall MnemoPay MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"sdk": {
"command": "npx",
"args": [
"-y",
"@mnemopay/sdk"
],
"env": {
"MNEMOPAY_API_KEY": "<YOUR_MNEMOPAY_API_KEY>"
}
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @mnemopay/sdk 1.15.2 in an isolated container with no network and no keys. It answered and listed 14 tools.
MnemoPay MCP tools 14
Read from the server with tools/listrememberStore a memory persisted across sessions. Importance auto-scored if omitted.
recallRecall top memories. Semantic search if query provided, else importance-ranked.
forgetPermanently delete a memory by ID.
reinforceBoost a memory's importance after it yielded a good outcome.
consolidatePrune stale memories below the decay threshold.
chargeCreate an escrow charge for delivered work. Max = $500 × reputation. See mnemopay://guide/tx.
settleFinalize a pending escrow. Releases funds, +0.01 reputation. See mnemopay://guide/tx.
refundRefund a transaction. Docks reputation -0.05 if already settled.
balanceCheck wallet balance and reputation score.
profileAgent stats: reputation, wallet, memory count, tx count.
logsAudit trail of memory and payment actions.
historyTransaction history, most recent first.
Show all 14 toolsShow fewer tools
disputeDispute a settled tx within 24h window. Freezes it pending resolution.
receipt_getGet a formatted receipt for a transaction.
Configuration
MNEMOPAY_API_KEYSecretMnemoPay API key from https://mnemopay.com/dashboard
MNEMOPAY_PERSIST_DIRDirectory where the local ledger + memory store persist (default: ~/.mnemopay)
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubMnemoPay
The governance layer for AI agents that take consequential actions. Charter-driven mission scope, policy enforcement with human-in-the-loop approvals, FiscalGate budget enforcement, EU AI Act Article 12 audit bundles, Agent Reputation Scoring (300-850), and a tamper-evident MerkleAudit chain — whether the action moves money or changes infrastructure.
MnemoPay sits above the rail (Stripe, Paystack, Lightning, Stripe MPP, x402, Google AP2) and below the agent runtime (LangChain, CrewAI, Claude Agent SDK, your own loop). The rail moves money. The runtime decides. MnemoPay declares the rules, enforces the budget, and produces the evidence.
Payments are one kind of consequential action. The same charter, policy, approval and audit path governs operational tooling too — the primitives do not care whether the step settles a payment or drains a node.
npm install @mnemopay/sdk
New here? Start at
docs/QUICKSTART.md— 60 seconds, three steps, working code.Docs: Quickstart · Architecture · Permissions · Action ledger · Integrations (OpenAI/Anthropic/Gemini/Cohere/Mistral/LangGraph) · Recall · FiscalGate · Audit bundles (EU AI Act Art. 12) · Subpath import rule · Claude Agent SDK guide · Bundlers: Vite · Webpack · Bun
Community: LICENSE (Apache 2.0) · CHANGELOG · CONTRIBUTING · CODE_OF_CONDUCT · SECURITY · Discussions · Good first issues
Receipts: Trust hub (entity, KYB, Apple Team ID, Article 12 audit chain — verify in <5 min) · Benchmarks (1M ops, 100% adversarial detection, $0 ledger drift) · Python SDK on PyPI (Mock/Stripe/Paystack/Lightning rails, scoring and
AuditChain; Charter, FiscalGate and Article 12 are TypeScript-only so far)
import MnemoPay, {
Charter, FiscalGate, MerkleAudit, // governance primitives
AgentReputationScoring, BehavioralEngine, // trust + reputation
StripeRail, X402Rail, GoogleAP2Rail, // rails
} from "@mnemopay/sdk";
const agent = MnemoPay.quick("my-agent");
await agent.remember("User prefers monthly billing");
const tx = await agent.charge(25, "Monthly API access"); // FiscalGate hold
await agent.settle(tx.id); // FiscalGate capture
// Agent Reputation Score — portable, 300-850 range. NOT FICO-brand, NOT a consumer
// credit report, NOT governed by FCRA. Scores agents (software), not humans.
const scorer = new AgentReputationScoring();
const result = scorer.compute({ transactions: [tx], createdAt: new Date(), /* ... */ });
// → { score: 672, rating: "good", feeRate: 0.015, trustLevel: "standard" }
Native Node ESM (
.mjsor"type": "module"): the package is CommonJS, so a default import yields the whole module object. Use the named export instead:import { MnemoPay, Charter } from "@mnemopay/sdk", thenMnemoPay.quick(...). The default-import form above works in TypeScript and bundlers.
14 modules. Hash-chained ledger. Charter / FiscalGate / Article 12 audit bundles. 6 payment rails. 200K-operation stress tested. Apache 2.0.
What MnemoPay is NOT: not a bank, not a money transmitter, not a Stripe replacement, not an agent framework, not a compliance platform. It's the rules-and-evidence layer between the rail and the runtime.
Governance latency (sub-second invariant)
"Sub-second governance" is a tested invariant, not marketing. The bench in tests/bench/governance-latency.bench.ts measures each governance hot path with vitest bench and emits a grep-able [gov-bench] summary line per scenario. Numbers below are steady-state percentiles from npm run bench:governance (run on the dev machine — your hardware will differ; the relative ordering is what matters).
| Hot path | p50 | p95 | p99 | machine |
|---|---|---|---|---|
policy.evaluateAction (EU AI Act, single tool_call) |
2.1 µs | 2.8 µs | 5.0 µs | Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11 |
MerkleAudit.record (append + chain hash) |
20 µs | 45 µs | 150 µs | Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11 |
MnemoPayLite.remember() end-to-end with auto-anchor (Ed25519) |
1.0 ms | 1.7 ms | 2.5 ms | Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11 |
Both per-event hot paths (evaluateAction, MerkleAudit.record) clear an entire EU AI Act policy gate and audit-chain write two orders of magnitude inside one millisecond. The end-to-end remember() path — including Ed25519 sign + sequence + chain emit — still sits comfortably inside the "sub-second governance" envelope with three decimal-orders of headroom.
A CI-enforced guard spec in tests/governance/latency-invariant.test.ts runs a degraded-mode sample on every npm test and fails if p95 for policy.evaluateAction regresses past 1 ms, or MerkleAudit.record past 5 ms. Bounds are sized to catch a ~10x regression, not flap on jitter.
How to reproduce: npm run bench:governance (full vitest.bench harness) or npm test -- latency-invariant (CI-bound check).
Native rails
Every rail ships with the same PaymentRail interface as StripeRail / PaystackRail / LightningRail:
| Rail | What it is |
|---|---|
StripeMPPRail |
Stripe Machine Payments Protocol — agent payments routed as crypto deposits on the Tempo network via Stripe-pinned API 2026-03-04.preview |
X402Rail |
Coinbase x402 (HTTP 402 revival) — USDC on Base L2 via EIP-3009 transferWithAuthorization. Pluggable signer (bring-your-own viem/ethers/noble). Zero crypto deps in the SDK. |
GoogleAP2Rail |
Google Agent Payment Protocol (FIDO Alliance, AP2 v0.2). Mandate VC + Intent VC + HTTP settlement. Pre-flight policy enforcement (caps, expiry, currency, recipients) before any signature is produced. |
Plus the Spatial governance fold — attachSpatialEvidence() co-signs the MerkleAudit chain with GridStamp proof-of-presence for embodied agents (drones, robots). Loose-coupled — no gridstamp runtime dependency.
Subpath imports for smaller, safer consumers
If you only need one MnemoPay module, import that subpath instead of the package root. This keeps MCP servers and other stdio tools quiet, avoids pulling unused middleware into bundles, and makes the dependency boundary obvious.
import { localEmbed, cosineSimilarity } from "@mnemopay/sdk/recall";
import { StripeRail, X402Rail } from "@mnemopay/sdk/rails";
import { SQLiteStorage } from "@mnemopay/sdk/storage";
import { CommerceEngine } from "@mnemopay/sdk/commerce";
Use the root import when you want the full SDK surface. Use @mnemopay/sdk/mcp only when you are intentionally mounting the MnemoPay MCP server.
Swarm (stable — v1.11+)
@mnemopay/sdk/swarm is the missing piece that browse.sh shipped as a public skill catalog. Ours adds the bit they don't: every agent in the swarm carries a DID, every action is FiscalGate-prechecked against per-agent + total caps, every TaskResult is appended to a shared Article-12 audit chain, and every skill invocation is billable through the same hash-chained ledger the rest of the SDK already uses.
CLI: npx @mnemopay/swarm list · npx @mnemopay/swarm demo — see mnemopay-swarm.
import { Swarm } from "@mnemopay/sdk/swarm";
import { AuditChain } from "@mnemopay/sdk/governance";
import { open } from "@mnemopay/browser"; // any BrowserProvider works
const provider = await someProviderFactory();
const swarm = new Swarm({
size: 4,
provider,
did: "did:mp:abc...",
budget: { perAgent: 0.25, total: 1.00 },
audit: { chain: new AuditChain() },
});
const run = await swarm.spawn([
{ id: "t1", skillId: "ramp.com/expense-create", prompt: "submit $42 lunch" },
{ id: "t2", skillId: "linear/issue-create", prompt: "file UI bug" },
{ id: "t3", skillId: "cloudflare/dns-record-set", prompt: "add CNAME" },
]);
const results = await swarm.gather(run);
const final = await swarm.recombine(results, "merge-json");
When to use it. Any time you'd open N parallel browser sessions to attack a problem — multi-source research, cross-platform issue triage, A/B-style "ask three agents, take the majority answer" — but you want one audit bundle, one budget envelope, and one place where billing happens.
Three recombine strategies (plus your own).
first-success— returns the output of the firstok:truetask; perfect for race patterns where any answer is fine.majority-vote— returns the most-common output acrossok:truetasks; perfect for fact-extraction where consensus matters.merge-json— deep-merges everyok:trueobject output with sorted keys (deterministic across runs).concat— joins string outputs with\nin spawn order.- Or pass any
(results) => unknowncallback.
Skill catalog. Public listings live at mcp.mnemopay.com/skills. The catalog is intentionally small and honestly marked — verified-partner badges only show after a real partnership is signed. Everything else carries verified: false, status: 'pending-partner' so you know exactly what trust tier you're getting.
BrowserSwarm — native browser-session fan-out (stable since 1.11.0)
@mnemopay/sdk/swarm/browser extends Swarm with a typed step sequence (goto / act / extract / screenshot / wait) per task and a lazy wire to @mnemopay/browser (optional peer dep — installing the SDK does NOT pull Playwright). Each task gets its own browser session, every step appends a browser.step event to the shared audit chain, and a thrown step kills only that one task — sibling sessions keep running.
import { BrowserSwarm } from "@mnemopay/sdk/swarm/browser";
const swarm = new BrowserSwarm({
size: 3, provider: undefined as never,
budget: { perAgent: 0.25, total: 1.00 },
browser: { provider: "stagehand" },
});
const run = await swarm.spawn([
{ id: "amzn", prompt: "amazon price", steps: [{type:"goto", url:"https://amazon.com/dp/X"}, {type:"extract", selector:"#priceblock_ourprice"}] },
{ id: "bby", prompt: "best buy price", steps: [{type:"goto", url:"https://bestbuy.com/site/X"},{type:"extract", selector:".priceView-customer-price"}] },
{ id: "tgt", prompt: "target price", steps: [{type:"goto", url:"https://target.com/p/X"}, {type:"extract", selector:"[data-test=product-price]"}] },
]);
const results = await swarm.gather(run); // BrowserTaskResult[] with .screenshots + .extractedData
File issues at github.com/mnemopay/mnemopay-sdk.
Audit-only middleware — .audit(client) with streaming + on-disk chain (1.11.0-alpha.0)
For chat widgets and regulated pipelines where ANY prompt mutation is a violation but Article-12 telemetry is still required:
import { AuditChain } from "@mnemopay/sdk/governance/audit-chain";
import { AnthropicMiddleware } from "@mnemopay/sdk/middleware/anthropic-audit";
const chain = new AuditChain({ path: "./.audit-chain/llm.jsonl" }); // file-backed since 1.11.0-alpha.0
const client = AnthropicMiddleware.audit(new Anthropic(), { chain });
// .create AND .stream now both emit one `llm.call` event per call. Streams
// that get cancelled mid-iteration emit `partial: true` with tokens-so-far.
for await (const chunk of client.messages.stream({ model, max_tokens, messages })) { /* ... */ }
@mnemopay/sdk/middleware/openai-audit exposes the equivalent shape for OpenAI — chat.completions.create({ stream: true }) is intercepted automatically (pass stream_options: { include_usage: true } to capture the final usage block).
Building an MCP server? Start here.
If you're shipping an MCP server and want to charge per-call — even sub-cent amounts — MnemoPay is built for you.
- Sub-cent payments via Lightning rail (impossible on Stripe/Paystack due to fees)
- Per-tool metering with
agent.charge(amount, toolName)— two lines of code - Agent Reputation Scoring gates abusive callers automatically — 300-850 reputation score, free tier + paid tier
- Cryptographic receipts every user can audit — no "trust me bro" billing
- Free indefinitely for the first 10 MCP servers that adopt it, subject to 90 days' written notice of any future change (email with your repo)
import MnemoPay from "@mnemopay/sdk";
const agent = MnemoPay.quick("my-mcp-server");
// Inside your tool handler:
const tx = await agent.charge(0.002, "embed_document"); // 0.2¢
if (tx.status === "blocked") return { error: "Payment declined" };
await agent.settle(tx.id);
// ... run the tool
Zero-config starter → production Lightning rail → Agent Reputation Scoring gating. Same API.
What Makes MnemoPay Different
$87M has been invested across 5 competitors. None have more than 3 of these 10 features:
| Feature | MnemoPay | Mem0 ($24M) | Skyfire ($9.5M) | Kite ($33M) | Payman ($14M) |
|---|---|---|---|---|---|
| Persistent Memory | Yes | Yes | No | No | No |
| Payment Rails (3) | Yes | No | USDC only | Stablecoin | Bank only |
| Agent Identity (KYA) | Yes | No | Building | Passport | No |
| Agent Reputation Scoring (300-850) | Yes | No | No | No | No |
| Behavioral Finance | Yes | No | No | No | No |
| Memory Integrity (Merkle) | Yes | No | No | No | No |
| EWMA Anomaly Detection | Yes | No | No | No | No |
| Double-Entry Ledger | Yes | No | No | No | No |
| Autonomous Commerce | Yes | No | No | No | No |
| Multi-Agent Network | Yes | No | Partial | Partial | No |
| Score | 10/10 | 1/10 | 2/10 | 2/10 | 1/10 |
Agent Reputation Scoring
A novel cross-session reputation scoring system for AI agents. Five-component scoring on a 300-850 range (familiar to developers from consumer credit; MnemoPay is not affiliated with Fair Isaac Corporation or any consumer credit bureau):
import { AgentReputationScoring } from "@mnemopay/sdk";
const scorer = new AgentReputationScoring();
const result = scorer.compute({
transactions: await agent.history(1000),
createdAt: agentCreationDate,
fraudFlags: 0,
disputeCount: 0,
disputesLost: 0,
warnings: 0,
budgetCap: 5000,
memoriesCount: agent.memories.size,
});
console.log(result.score); // 742
console.log(result.rating); // "very_good"
console.log(result.feeRate); // 0.013 (1.3%)
console.log(result.trustLevel); // "high"
console.log(result.requiresHITL); // false
| Component | Weight | What It Measures |
|---|---|---|
| Payment History | 35% | Success rate, disputes, recency-weighted |
| Credit Utilization | 20% | Spend vs budget cap, sweet spot 10-30% |
| History Length | 15% | Account age, activity density |
| Behavior Diversity | 15% | Counterparties, categories, amount range |
| Fraud Record | 15% | Fraud flags, disputes lost, warnings |
| Score Range | Rating | Trust Level | Fee Rate |
|---|---|---|---|
| 800-850 | Exceptional | Full trust | 1.0% |
| 740-799 | Very Good | High trust | 1.3% |
| 670-739 | Good | Standard | 1.5% |
| 580-669 | Fair | Reduced | 1.9% |
| 300-579 | Poor | Minimal + HITL | 2.5% |
Behavioral Finance Engine
Peer-reviewed behavioral economics from Nobel laureate Daniel Kahneman and collaborators. Every parameter cited to published research.
import { BehavioralEngine } from "@mnemopay/sdk";
const behavioral = new BehavioralEngine();
// Prospect Theory (Kahneman & Tversky, 1992)
// Losses hurt 2.25x more than gains feel good
behavioral.prospectValue(100); // { value: 57.5, domain: "gain" }
behavioral.prospectValue(-100); // { value: -129.5, domain: "loss" }
// Should the agent wait before buying?
const cooling = behavioral.coolingOff(2000, 5000); // amount, monthly income
// → { recommended: true, hours: 3.2, riskLevel: "high", regretProbability: 0.65 }
// Frame spending as goal delay (2.25x more effective than gain framing)
const frame = behavioral.lossFrame(200, {
name: "Emergency Fund", target: 10000, current: 3000, monthlySavings: 500
});
// → "This $200 purchase delays your Emergency Fund goal by 12 days."
// Save More Tomorrow (Thaler & Benartzi, 2004)
const smart = behavioral.commitmentDevice(0.035, 0.03, 4);
// → { finalRate: 0.095, explanation: "3.5% → 9.5% over 4 raise cycles" }
// Predict regret from purchase history
behavioral.recordRegret({ amount: 300, category: "gadgets", regretScore: 8, timestamp: "..." });
const prediction = behavioral.predictRegret(400, "gadgets");
// → { probability: 0.72, triggerCoolingOff: true }
Research sources: Tversky & Kahneman 1992, Laibson 1997, Thaler & Benartzi 2004, Barber & Odean 2000, Nunes & Dreze 2006, Shiller 2000.
Memory Integrity (Merkle Tree)
Tamper-evident memory. If anyone injects, modifies, or deletes an agent's memories, the Merkle root changes and you know.
import { MerkleTree } from "@mnemopay/sdk";
const tree = new MerkleTree();
// Every memory write adds a leaf
tree.addLeaf("mem-1", "User prefers monthly billing");
tree.addLeaf("mem-2", "Last purchase was $25 API access");
// Take periodic snapshots
const snapshot = tree.snapshot();
// → { rootHash: "a3f2...", leafCount: 2, snapshotHash: "b7c1..." }
// Later: check if memories were tampered
const check = tree.detectTampering(snapshot);
// → { tampered: false, summary: "Integrity verified. 2 memories, root matches." }
// Prove a specific memory exists without revealing others
const proof = tree.getProof("mem-1");
MerkleTree.verifyProof(proof); // true
Defends against: MemoryGraft injection, silent deletion, content tampering, replay attacks, reordering attacks.
Anomaly Detection (EWMA + Behavioral Fingerprinting + Canaries)
Three independent systems that catch compromised agents.
import { EWMADetector, BehaviorMonitor, CanarySystem } from "@mnemopay/sdk";
// 1. EWMA: real-time streaming anomaly detection
const detector = new EWMADetector(0.15, 2.5, 3.5, 10);
detector.update(100); // normal
detector.update(100); // normal
detector.update(9999); // → { anomaly: true, severity: "critical", zScore: 8.2 }
// 2. Behavioral fingerprinting: detect hijacked agents
const monitor = new BehaviorMonitor({ warmupPeriod: 10 });
// Build profile over time
monitor.observe("agent-1", { amount: 100, hourOfDay: 14, chargesPerHour: 2 });
// Sudden change = suspected hijack
monitor.observe("agent-1", { amount: 9999, hourOfDay: 3, chargesPerHour: 50 });
// → { suspected: true, severity: "critical", anomalousFeatures: 3 }
// 3. Canary honeypots: plant traps for compromised agents
const canary = new CanarySystem();
const trap = canary.plant("transaction");
canary.check(trap.id, "rogue-agent");
// → { severity: "critical", message: "CANARY TRIGGERED: Agent compromised" }
Math: mu_t = alpha * x_t + (1 - alpha) * mu_{t-1}, alert when |x_t - mu_t| > k * sigma_t (Roberts 1959, Lucas & Saccucci 1990).
Memory (Compounding Knowledge Base)
Not a traditional RAG lookup. MnemoPay memories compound — every transaction strengthens associated context, weak memories decay, strong ones consolidate. The same pattern Karpathy describes as "LLM Wiki" but applied to payments and trust.
- Ebbinghaus forgetting curve — memories decay naturally over time
- Hebbian reinforcement — successful transactions strengthen associated memories
- RL feedback loop —
rlFeedback(ids, reward)applies EWMA importance updates after agent actions - Consolidation — auto-prunes weak memories, keeps what matters
- Semantic recall — find memories by relevance, not just recency
- 100KB per memory — store rich context, not just strings
// After a recall + action, signal usefulness with rlFeedback
const memories = await agent.recall("user preferences", 5);
// ... agent acts on recalled memories ...
await agent.rlFeedback(memories.map(m => m.id), +1.0); // +1 = useful, -1 = not useful
Choosing a persistence adapter
Recall is backed by a pluggable PersistenceAdapter. Pick by deployment shape:
| Adapter | Infra | Best for | Import |
|---|---|---|---|
MemoryAdapter (default) |
none | dev, tests, ephemeral agents | built-in |
SQLiteAdapter |
one file (better-sqlite3) |
single-node, local-first, edge | @mnemopay/sdk/storage |
PostgresAdapter / NeonAdapter |
Postgres + pgvector | hosted/multi-node prod (Neon, Supabase, RDS/Aurora, Cloud SQL) | @mnemopay/sdk/recall/postgres |
PostgresAdapter and NeonAdapter are the same pgvector-backed implementation
— "Neon" is just hosted Postgres; use whichever name fits your infra.
import { MnemoPay } from "@mnemopay/sdk";
// Via MnemoPay.create — { type: "postgres" } (alias of "neon")
const agent = await MnemoPay.create({
agentId: "agent-1",
persist: { type: "postgres", url: process.env.DATABASE_URL! },
});
// Or construct the adapter directly
import { PostgresAdapter, postgresMigrationSql } from "@mnemopay/sdk/recall/postgres";
const adapter = new PostgresAdapter({ url: process.env.DATABASE_URL! });
The schema (a vector(384) column + HNSW cosine index) is auto-created on the
first write. To manage it with your own migration tool instead, run the DDL
from postgresMigrationSql(table?, dimensions?) and pass skipBootstrap: true.
Requires the optional peer dep: npm install pg.
Reputation Streaks & Badges
Agents earn trust over time. Consecutive successful settlements build streaks that unlock badges and reduce fees.
const rep = await agent.reputation();
console.log(rep.streak);
// → { currentStreak: 47, bestStreak: 312, streakBonus: 0.094 }
console.log(rep.badges);
// → [
// { id: "first_settlement", name: "First Settlement", earnedAt: 1712700000000 },
// { id: "streak_50", name: "Streak Master", earnedAt: 1712900000000 },
// { id: "volume_10k", name: "High Roller", earnedAt: 1713100000000 },
// ]
| Badge | Requirement |
|---|---|
| First Settlement | Complete 1 settlement |
| Streak 10 | 10 consecutive settlements |
| Streak 50 | 50 consecutive settlements |
| Volume $1K | $1,000+ total settled |
| Volume $10K | $10,000+ total settled |
| Perfect Record | 100+ settlements, 0 disputes |
Streaks reset on refunds or disputes. Streak bonuses compound reputation up to +10%.
MnemoPay MCP questions
How do I add MnemoPay MCP to Claude Code?
Run claude mcp add --env 'MNEMOPAY_API_KEY=<YOUR_MNEMOPAY_API_KEY>' sdk -- npx -y @mnemopay/sdk in your terminal. Add --scope user to make it available in every project.
How do I add MnemoPay MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does MnemoPay MCP provide?
It exposes 14 tools, including remember, recall, forget, reinforce, consolidate.
What is MnemoPay's role in the AI stack?
It sits between the payment rails and the agent runtime, declaring rules, enforcing budgets, and producing evidence.
Does MnemoPay replace Stripe?
No, it is not a Stripe replacement; it is a rules-and-evidence layer that sits above payment rails like Stripe.
How does the Agent Reputation Scoring work?
It provides a portable score in the 300-850 range to score software agents rather than humans.