MnemoPay

Camada de confiança e reputação para agentes de IA que lidam com dinheiro. Score de crédito do agente (300-850), ledger encadeado por hash, finanças comportamentais, meios de pagamento reais (Stripe, Paystack, Lightning), compras autônomas com garantia.

GitHub

Experimente este MCPPatrocinado

Documentação

MnemoPay

A camada de governança para agentes de IA que lidam com dinheiro. Escopo de missão orientado por charter, aplicação de orçamento FiscalGate, pacotes de auditoria do Artigo 12 da Lei de IA da UE, Agent Reputation Scoring (300-850) e uma cadeia MerkleAudit à prova de adulteração — em todos os trilhos de pagamento que um agente possa tocar.

MnemoPay fica acima do trilho (Stripe, Paystack, Lightning, Stripe MPP, x402, Google AP2) e abaixo do runtime do agente (LangChain, CrewAI, Claude Agent SDK, seu próprio loop). O trilho move o dinheiro. O runtime decide. MnemoPay declara as regras, aplica o orçamento e produz as evidências.

npm install @mnemopay/sdk

Novo por aqui? Comece em docs/QUICKSTART.md — 60 segundos, três passos, código funcional.

Documentação: Quickstart · Arquitetura · Permissões · Action ledger · Integrações (OpenAI/Anthropic/Gemini/Cohere/Mistral/LangGraph) · Recall · FiscalGate · Pacotes de auditoria (EU AI Act Art. 12) · Regra de importação de subpath · Guia do Claude Agent SDK · Bundlers: Vite · Webpack · Bun

Comunidade: LICENSE (Apache 2.0) · CHANGELOG · CONTRIBUTING · CODE_OF_CONDUCT · SECURITY · Discussões · Boas primeiras issues

Comprovantes: Trust hub (entidade, KYB, Apple Team ID, cadeia de auditoria do Artigo 12 — verifique em <5 min) · Benchmarks (1M operações, 100% de detecção adversarial, $0 de deriva no ledger) · Python SDK no PyPI (paridade total com os trilhos TS desde 1.1.0)

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" }

14 módulos. Ledger com cadeia de hash. Charter / FiscalGate / pacotes de auditoria do Artigo 12. 6 trilhos de pagamento. Testado sob estresse com 200 mil operações. Apache 2.0.

O que MnemoPay NÃO é: não é um banco, não é um transmissor de dinheiro, não é um substituto do Stripe, não é um framework de agentes, não é uma plataforma de compliance. É a camada de regras e evidências entre o trilho e o runtime.

Latência de governança (invariante de sub-segundo)

"Governança em sub-segundo" é um invariante testado, não marketing. O bench em tests/bench/governance-latency.bench.ts mede cada hot path de governança com vitest bench e emite uma linha de resumo [gov-bench] pesquisável com grep por cenário. Os números abaixo são percentis de estado estável do npm run bench:governance (executado na máquina de desenvolvimento — seu hardware será diferente; a ordem relativa é o que importa).

Hot path	p50	p95	p99	máquina
`policy.evaluateAction` (EU AI Act, tool_call único)	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 com auto-anchor (Ed25519)	1,0 ms	1,7 ms	2,5 ms	Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11

Ambos os hot paths por evento (evaluateAction, MerkleAudit.record) atravessam um gate de política completo do EU AI Act e a escrita na cadeia de auditoria duas ordens de magnitude dentro de um milissegundo. O caminho end-to-end remember() — incluindo assinatura Ed25519 + sequência + emissão da cadeia — ainda fica confortavelmente dentro do envelope de "governança em sub-segundo" com três ordens decimais de folga.

Uma spec de guarda aplicada por CI em tests/governance/latency-invariant.test.ts executa uma amostra em modo degradado a cada npm test e falha se o p95 de policy.evaluateAction regredir além de 1 ms, ou MerkleAudit.record além de 5 ms. Os limites são dimensionados para capturar uma regressão de ~10x, não para oscilar com jitter.

Como reproduzir: npm run bench:governance (harness completo de vitest.bench) ou npm test -- latency-invariant (verificação vinculada à CI).

Trilhos nativos

Cada trilho acompanha a mesma interface PaymentRail que StripeRail / PaystackRail / LightningRail:

Trilho	O que é
`StripeMPPRail`	Stripe Machine Payments Protocol — pagamentos de agentes roteados como depósitos cripto na rede Tempo via API fixada do Stripe `2026-03-04.preview`
`X402Rail`	Coinbase x402 (revival do HTTP 402) — USDC na Base L2 via EIP-3009 `transferWithAuthorization`. Assinante plugável (traga seu próprio viem/ethers/noble). Zero dependências cripto no SDK.
`GoogleAP2Rail`	Google Agent Payment Protocol (FIDO Alliance, AP2 v0.2). Mandate VC + Intent VC + liquidação HTTP. Aplicação de política pré-voo (limites, expiração, moeda, destinatários) antes de qualquer assinatura ser produzida.

Mais a dobra de governança espacial — attachSpatialEvidence() co-assina a cadeia MerkleAudit com prova de presença GridStamp para agentes incorporados (drones, robôs). Fracamente acoplado — sem dependência de runtime gridstamp.

Imports de subpath para consumidores menores e mais seguros

Se você precisar de apenas um módulo do MnemoPay, importe esse subpath em vez da raiz do pacote. Isso mantém servidores MCP e outras ferramentas stdio silenciosos, evita puxar middleware não utilizado para os bundles e torna o limite de dependência óbvio.

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 o import da raiz quando quiser a superfície completa do SDK. Use @mnemopay/sdk/mcp apenas quando estiver montando intencionalmente o servidor MCP do MnemoPay.

Swarm (estável — v1.11+)

@mnemopay/sdk/swarm é a peça que faltava e que a browse.sh lançou como catálogo público de skills. A nossa adiciona o que eles não têm: cada agente no swarm carrega um DID, cada ação é pré-verificada pelo FiscalGate contra limites por agente + totais, cada TaskResult é anexado a uma cadeia de auditoria compartilhada do Artigo 12, e cada invocação de skill é cobrável através do mesmo ledger com cadeia de hash que o resto do SDK já usa.

CLI: npx @mnemopay/swarm list · npx @mnemopay/swarm demo — veja 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");

Quando usar. Sempre que você abriria N sessões de navegador em paralelo para atacar um problema — pesquisa multi-fonte, triagem de issues entre plataformas, estilo A/B de "pergunte a três agentes, fique com a resposta da maioria" — mas você quer um único pacote de auditoria, um único envelope de orçamento e um único lugar onde a cobrança acontece.

Três estratégias de recombinação (mais a sua própria).

first-success — retorna a saída da primeira tarefa ok:true; perfeito para padrões de corrida onde qualquer resposta serve.
majority-vote — retorna a saída mais comum entre as tarefas ok:true; perfeito para extração de fatos onde consenso importa.
merge-json — faz deep-merge de cada saída de objeto ok:true com chaves ordenadas (determinístico entre execuções).
concat — junta saídas de string com \n na ordem de spawn.
Ou passe qualquer callback (results) => unknown.

Catálogo de skills. Listagens públicas ficam em mcp.mnemopay.com/skills. O catálogo é intencionalmente pequeno e marcado com honestidade — selos de parceiro verificado só aparecem depois que uma parceria real é assinada. Todo o resto carrega verified: false, status: 'pending-partner' para você saber exatamente qual nível de confiança está recebendo.

BrowserSwarm — fan-out nativo de sessões de navegador (estável desde 1.11.0)

@mnemopay/sdk/swarm/browser estende Swarm com uma sequência de passos tipada (goto / act / extract / screenshot / wait) por tarefa e uma conexão lazy com @mnemopay/browser (peer dep opcional — instalar o SDK NÃO puxa o Playwright). Cada tarefa tem sua própria sessão de navegador, cada passo anexa um evento browser.step à cadeia de auditoria compartilhada, e um passo que lança erro mata apenas aquela tarefa — as sessões irmãs continuam rodando.

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

Abra issues em github.com/mnemopay/mnemopay-sdk.

Middleware somente auditoria — `.audit(client)` com streaming + cadeia em disco (1.11.0-alpha.0)

Para widgets de chat e pipelines regulados onde QUALQUER mutação de prompt é uma violação, mas a telemetria do Artigo 12 ainda é obrigatória:

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 expõe a forma equivalente para OpenAI — chat.completions.create({ stream: true }) é interceptado automaticamente (passe stream_options: { include_usage: true } para capturar o bloco final de usage).

Construindo um servidor MCP? Comece aqui.

Se você está lançando um servidor MCP e quer cobrar por chamada — até valores de sub-centavo — MnemoPay foi feito para você.

Pagamentos de sub-centavo via trilho Lightning (impossível no Stripe/Paystack por causa das taxas)
Medição por ferramenta com agent.charge(amount, toolName) — duas linhas de código
Agent Reputation Scoring bloqueia chamadores abusivos automaticamente — pontuação de reputação 300-850, camada gratuita + camada paga
Recibos criptográficos que todo usuário pode auditar — sem cobrança de "confia em mim"
Gratuito indefinidamente para os primeiros 10 servidores MCP que o adotarem, sujeito a aviso prévio por escrito de 90 dias para qualquer mudança futura (email com seu repositório)

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

Starter de zero configuração → trilho Lightning de produção → bloqueio por Agent Reputation Scoring. Mesma API.

O Que Torna MnemoPay Diferente

US$ 87 milhões foram investidos em 5 concorrentes. Nenhum tem mais de 3 dessas 10 funcionalidades:

Funcionalidade	MnemoPay	Mem0 ($24M)	Skyfire ($9.5M)	Kite ($33M)	Payman ($14M)
Memória Persistente	Sim	Sim	Não	Não	Não
Trilhos de Pagamento (3)	Sim	Não	Somente USDC	Stablecoin	Somente banco
Identidade de Agente (KYA)	Sim	Não	Em construção	Passport	Não
Agent Reputation Scoring (300-850)	Sim	Não	Não	Não	Não
Finanças Comportamentais	Sim	Não	Não	Não	Não
Integridade de Memória (Merkle)	Sim	Não	Não	Não	Não
Detecção de Anomalias (EWMA)	Sim	Não	Não	Não	Não
Ledger de Partidas Dobradas	Sim	Não	Não	Não	Não
Comércio Autônomo	Sim	Não	Não	Não	Não
Rede Multi-Agente	Sim	Não	Parcial	Parcial	Não
Pontuação	10/10	1/10	2/10	2/10	1/10

Agent Reputation Scoring

Um sistema inovador de pontuação de reputação entre sessões para agentes de IA. Pontuação de cinco componentes na faixa de 300-850 (familiar para desenvolvedores do crédito ao consumidor; MnemoPay não é afiliado à Fair Isaac Corporation nem a nenhum bureau de crédito ao consumidor):

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

Componente	Peso	O Que Mede
Histórico de Pagamentos	35%	Taxa de sucesso, disputas, ponderado por recência
Utilização de Crédito	20%	Gasto vs limite de orçamento, ponto ideal 10-30%
Duração do Histórico	15%	Idade da conta, densidade de atividade
Diversidade de Comportamento	15%	Contrapartes, categorias, faixa de valores
Registro de Fraude	15%	Flags de fraude, disputas perdidas, avisos

Faixa de Pontuação	Classificação	Nível de Confiança	Taxa
800-850	Excepcional	Confiança total	1,0%
740-799	Muito Bom	Alta confiança	1,3%
670-739	Bom	Padrão	1,5%
580-669	Razoável	Reduzida	1,9%
300-579	Ruim	Mínima + HITL	2,5%

Motor de Finanças Comportamentais

Economia comportamental revisada por pares do laureado com Nobel Daniel Kahneman e colaboradores. Cada parâmetro citado em pesquisa publicada.

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 }

Fontes de pesquisa: Tversky & Kahneman 1992, Laibson 1997, Thaler & Benartzi 2004, Barber & Odean 2000, Nunes & Dreze 2006, Shiller 2000.

Integridade de Memória (Árvore de Merkle)

Memória à prova de adulteração. Se alguém injetar, modificar ou excluir as memórias de um agente, a raiz Merkle muda e você fica sabendo.

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

Defende contra: injeção MemoryGraft, exclusão silenciosa, adulteração de conteúdo, ataques de replay, ataques de reordenação.

Detecção de Anomalias (EWMA + Fingerprinting Comportamental + Canários)

Três sistemas independentes que capturam agentes comprometidos.

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" }

Matemática: mu_t = alpha * x_t + (1 - alpha) * mu_{t-1}, alerta quando |x_t - mu_t| > k * sigma_t (Roberts 1959, Lucas & Saccucci 1990).

Memória (Base de Conhecimento Composta)

Não é uma consulta RAG tradicional. As memórias do MnemoPay se acumulam — cada transação fortalece o contexto associado, memórias fracas decaem, as fortes se consolidam. O mesmo padrão que Karpathy descreve como "LLM Wiki", mas aplicado a pagamentos e confiança.

Curva do esquecimento de Ebbinghaus — memórias decaem naturalmente com o tempo
Reforço hebbiano — transações bem-sucedidas fortalecem memórias associadas
Loop de feedback RL — rlFeedback(ids, reward) aplica atualizações de importância EWMA após ações do agente
Consolidação — poda automaticamente memórias fracas, mantém o que importa
Recuperação semântica — encontre memórias por relevância, não apenas por recência
100KB por memória — armazene contexto rico, não apenas 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

Escolhendo um adaptador de persistência

A recuperação é suportada por um PersistenceAdapter plugável. Escolha pelo formato de implantação:

Adaptador	Infraestrutura	Melhor para	Importação
`MemoryAdapter` (padrão)	nenhuma	desenvolvimento, testes, agentes efêmeros	embutido
`SQLiteAdapter`	um arquivo (`better-sqlite3`)	nó único, local-first, edge	`@mnemopay/sdk/storage`
`PostgresAdapter` / `NeonAdapter`	Postgres + pgvector	produção hospedada/multinó (Neon, Supabase, RDS/Aurora, Cloud SQL)	`@mnemopay/sdk/recall/postgres`

PostgresAdapter e NeonAdapter são a mesma implementação baseada em pgvector — "Neon" é apenas Postgres hospedado; use o nome que se adequar à sua infraestrutura.

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! });

O esquema (uma coluna vector(384) + índice HNSW de cosseno) é criado automaticamente na primeira gravação. Para gerenciá-lo com sua própria ferramenta de migração, execute o DDL de postgresMigrationSql(table?, dimensions?) e passe skipBootstrap: true. Requer a dependência opcional: npm install pg.

Sequências de Reputação e Selos

Agentes ganham confiança ao longo do tempo. Liquidações bem-sucedidas consecutivas constroem sequências que desbloqueiam selos e reduzem taxas.

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 },
// ]

Selo	Requisito
Primeira Liquidação	Concluir 1 liquidação
Sequência 10	10 liquidações consecutivas
Sequência 50	50 liquidações consecutivas
Volume $1K	$1.000+ liquidados no total
Volume $10K	$10.000+ liquidados no total
Registro Perfeito	100+ liquidações, 0 disputas

Sequências são zeradas em reembolsos ou disputas. Bônus de sequência acumulam reputação em até +10%.

Ledger Encadeado por Hash

Cada entrada do ledger se liga à anterior via cadeia de hash SHA-256. Se qualquer entrada for modificada, a cadeia quebra e verify() detecta instantaneamente.

const summary = agent.ledger.verify();
console.log(summary.chainValid);     // true
console.log(summary.chainIntegrity); // 1.0 (100% of links verified)

Combinado com integridade Merkle nas memórias e HMAC nas transações, o MnemoPay oferece três sistemas independentes de detecção de adulteração.

Pagamentos (partidas dobradas com precisão de centavos)

Contabilidade de partidas dobradas — todo débito tem um crédito, sempre equilibra em zero
Fluxo de custódia — cobrança -> retenção -> liquidação -> reembolso (mesmo formato do Stripe/Square)
Taxas por faixa de volume — 1,9% / 1,5% / 1,0% com base no volume acumulado
3 trilhos de pagamento — Paystack (África), Stripe (global), Lightning (BTC)
Matemática inteira com precisão de centavos — testada sob estresse com 200.000 transações em 50 agentes concorrentes, zero desvio

Identidade (Conformidade KYA)

Identidade criptográfica — pares de chaves HMAC-SHA256, proteção contra replay
Tokens de capacidade — permissões com escopo e limites de gasto
Listas de contrapartes permitidas — restrinja com quem o agente pode transacionar
Interruptor de emergência — revogue todos os tokens instantaneamente

Detecção de Fraude (nível ML)

Verificações de velocidade — limites por minuto/hora/dia
Floresta de Isolamento — detecção de anomalias ML não supervisionada
Aprimorado por geolocalização — rastreamento de país, detecção de saltos rápidos, sanções OFAC
Motor adaptativo — AIMD assimétrico, anti-jogo, disjuntor, detecção de desvio PSI

Comércio Multi-Agente

CommerceEngine — compras autônomas com mandatos, custódia, callbacks de aprovação
MnemoPayNetwork — registre agentes, execute negócios, contexto de memória compartilhado
Cadeias de suprimentos — cadeias de agentes de 10 etapas, marketplaces de 100 agentes, tudo testado

Integração com o Claude Agent SDK

Duas primitivas construídas especificamente para o padrão do Claude Agent SDK, onde um orquestrador Opus cria subagentes Sonnet/Haiku.

Cache de prompt de 1 hora em resultados de recuperação

Ao alimentar a recuperação do MnemoPay em um prompt de sistema do Claude, use formatForClaudeCache() para emitir um bloco de conteúdo com cache_control: { type: "ephemeral", ttl: 3600 }. A API da Anthropic armazena em cache esse prefixo por até 1 hora; leituras de cache são cobradas a aproximadamente 10% da taxa normal de entrada. Com prefixos de recuperação estáveis e um cache de 1h aquecido, usuários observaram economias na faixa típica de 85-92% na porção de recuperação dos tokens de entrada — seus resultados reais dependem da frequência de chamadas e da estabilidade do conjunto de memórias.

import MnemoPay, { formatForClaudeCache } from "@mnemopay/sdk";
import Anthropic from "@anthropic-ai/sdk";

const agent = MnemoPay.quick("my-agent");
const anthropic = new Anthropic();

// Option A: recall() directly returns a cache block
const cacheBlock = await agent.recall("user preferences", 10, {
  formatForClaudeCache: true,
});

// Option B: convert an existing memory array (no extra recall call)
const memories = await agent.recall("user preferences", 10);
const cacheBlock2 = MnemoPay.formatForClaudeCache(memories);
// OR: formatForClaudeCache(memories) from the module directly

const response = await anthropic.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 1024,
  system: [
    { type: "text", text: "You are a helpful assistant.", cache_control: { type: "ephemeral" } },
    cacheBlock,  // ← MnemoPay recall cached for 1 hour
  ],
  messages: [{ role: "user", content: userMessage }],
});

O texto serializado é ordenado por id de memória, para que conjuntos de memória idênticos produzam saída byte-idêntica — necessário para que o prefixo de cache seja atingido em turnos subsequentes.

Atribuição de custo por subagente

Rastreie quanto cada subagente em um pipeline multi-agente gastou — registrado como pares de partidas dobradas no ledger para manter a auditoria limpa.

import MnemoPay, { SubagentCostTracker } from "@mnemopay/sdk";

const orchestrator = MnemoPay.quick("orchestrator");

// After each Claude API call, record the cost:
orchestrator.subagentCosts.attributeSubagentCost({
  parentAgentId: "orchestrator",
  subagentId: "researcher-1",
  subagentRole: "researcher",
  modelId: "claude-sonnet-4-6",
  inputTokens: 5000,
  outputTokens: 2000,
  cacheReadTokens: 8500,   // tokens served from the 1h recall cache
  cacheWriteTokens: 500,
  cacheWriteTtl: "1h",
});

// At end of pipeline, get breakdown ordered by cost:
const breakdown = orchestrator.subagentCosts.subagentCostBreakdown("orchestrator");
// → [{ subagentId, subagentRole, modelId, totalCostUsd, cacheSavingsUsd, ... }]

const totalSaved = orchestrator.subagentCosts.totalCacheSavings("orchestrator");

Tabela de preços usada: tarifas da lista da Anthropic 2026 (Opus 4.7 $5/$25/M, Sonnet 4.6 $3/$15/M, Haiku 4.5 $1/$5/M; leituras de cache 0,1×, gravações de 1h 2×). Atualize MODEL_PRICING em src/subagent-cost.ts se as tarifas mudarem.

Veja docs/agent-sdk-guide.md para um passo a passo completo de integração.

Trilhos de Pagamento

Cada trilho implementa a mesma interface PaymentRail — createHold / capturePayment / reversePayment. Troque trilhos sem tocar no código do agente.

Trilho	Cobertura
`StripeRail`	Cartões (USD, EUR, GBP, +)
`PaystackRail`	África (NGN, GHS, ZAR, KES)
`LightningRail`	Micropagamentos BTC abaixo de um centavo
`StripeMPPRail`	Depósitos cripto no Tempo via Stripe MPP
`X402Rail`	USDC na Base via EIP-3009 transferWithAuthorization
`GoogleAP2Rail`	Liquidação orientada por mandato AP2 v0.2 (FIDO Alliance)

import {
  PaystackRail, StripeRail, LightningRail,
  StripeMPPRail, X402Rail, GoogleAP2Rail,
} from "@mnemopay/sdk";

const paystack  = new PaystackRail(process.env.PAYSTACK_SECRET_KEY!);
const stripe    = new StripeRail(process.env.STRIPE_SECRET_KEY!);
const lightning = new LightningRail(LND_URL, MACAROON);

const mpp   = new StripeMPPRail(process.env.STRIPE_SECRET_KEY!);
const x402  = new X402Rail({ signer: yourEip3009Signer });   // bring-your-own crypto
const ap2   = new GoogleAP2Rail({ mandate, endpoint, signer });

const agent = MnemoPay.quick("my-agent", { paymentRail: paystack });

Stripe — cobranças reais em cartão com clientes salvos

Fluxo de ponta a ponta para cobrar o cartão salvo de um usuário sem handoff de navegador:

import MnemoPay, { StripeRail } from "@mnemopay/sdk";

const rail = new StripeRail(process.env.STRIPE_SECRET_KEY!);
const agent = MnemoPay.quick("agent-1", { paymentRail: rail });

// 1. Create a Stripe customer (one-time, persist cus_... to your DB)
const { customerId } = await rail.createCustomer("user@example.com", "Jerry O");

// 2. Collect a card via Stripe.js: create a SetupIntent, return client_secret
//    to the browser, let Stripe Elements confirm it. You receive pm_... from
//    the webhook or confirmation callback. Save it alongside the customer.
const { clientSecret } = await rail.createSetupIntent(customerId);
// → hand clientSecret to frontend, get back paymentMethodId after confirm

// 3. Charge the saved card later, off-session, no user interaction needed
const tx = await agent.charge(25, "Monthly API access", undefined, {
  customerId,
  paymentMethodId: "pm_saved_from_step_2",
  offSession: true,
});

// 4. Settle (captures the hold) or refund (releases it)
await agent.settle(tx.id);

O Paystack suporta o mesmo padrão via authorizationCode:

const tx = await agent.charge(5000, "NGN invoice", undefined, {
  email: "customer@example.com",
  authorizationCode: "AUTH_abc123", // from an earlier Paystack transaction
});

Servidor MCP

npx @mnemopay/sdk init
# or
claude mcp add mnemopay -s user -- npx -y @mnemopay/sdk

Grupo de ferramentas padrão: essentials (14 ferramentas, ~1K tokens). Um dos servidores MCP mais leves que você pode instalar — o MnemoPay carrega apenas memória + carteira + transações por padrão, para não sobrecarregar o orçamento de contexto do seu agente.

memory: remember, recall, forget, reinforce, consolidate
wallet: balance, profile, history, logs
tx: charge, settle, refund, dispute, receipt_get

Precisa de mais? Opte ativamente:

npx @mnemopay/sdk --tools=all       # all 95 tools
npx @mnemopay/sdk --tools=agent     # essentials + commerce + hitl + payments + webhooks
npx @mnemopay/sdk --tools=reputation  # Agent Reputation Scoring only

Grupos: memory, wallet, tx, commerce, hitl, payments, webhooks, reputation, security, governance, identity, skills, spatial, agent_os, organization_admin, operator. Aliases: essentials (padrão), agent, all. Também configurável via variável de ambiente MNEMOPAY_TOOLS.

Mudança significativa na v1.3.0: o padrão era all, agora é essentials. Se você dependia de commerce/hitl/webhooks/fico/security disponíveis sem flag, passe --tools=all ou --tools=agent. Veja CHANGELOG.

Middleware

Proxies plug-and-play que tornam a recuperação invisível: cada chamada de chat injeta automaticamente as principais memórias como contexto de sistema e armazena a troca depois. Mesmo formato Middleware.wrap(client, agent) em todos os provedores.

// OpenAI
import { mnemoPayMiddleware } from "@mnemopay/sdk/middleware/openai";

// Anthropic
import { mnemoPayMiddleware } from "@mnemopay/sdk/middleware/anthropic";

// Gemini
import { GeminiMiddleware } from "@mnemopay/sdk/middleware/gemini";

// Cohere (v2 chat API)
import { CohereMiddleware } from "@mnemopay/sdk/middleware/cohere";
const cohere = CohereMiddleware.wrap(new CohereClientV2({ token }), agent);

// Mistral
import { MistralMiddleware } from "@mnemopay/sdk/middleware/mistral";
const mistral = MistralMiddleware.wrap(new Mistral({ apiKey }), agent);

// LangGraph
import { mnemoPayTools } from "@mnemopay/sdk/langgraph";

Arquitetura

Diagrama completo da pilha e mapa de módulos: docs/architecture.md.

┌──────────────────────────────────────────────────────────────────┐
│                       MnemoPay SDK                                │
│              Governance · Memory · Payments · Identity            │
├─────────────────────────────────────────────────────────────────┤
│ GOVERNANCE  Charter · FiscalGate · Article 12 · MerkleAudit      │
│             mission scope, budget enforcement, audit bundles     │
├──────────┬──────────┬───────────┬─────────────────────────────────┤
│  Memory  │ Payments │ Identity  │  Agent Reputation Scoring       │
│          │          │           │  300-850, 5-component           │
│ remember │ charge   │ KYA       ├─────────────────────────────────┤
│ recall   │ settle   │ tokens    │  Behavioral Finance             │
│ reinforce│ refund   │ perms     │  prospect theory, nudges        │
│ forget   │ dispute  │ killswitch├─────────────────────────────────┤
│          │          │           │  Anomaly Detection              │
│          │          │           │  EWMA + fingerprinting          │
├──────────┴──────────┴───────────┼─────────────────────────────────┤
│     Double-Entry Ledger         │  Merkle Integrity               │
│  debit + credit = always zero   │  tamper-evident memory          │
├─────────────────────────────────┼─────────────────────────────────┤
│     Fraud Guard (ML-grade)      │  Canary Honeypots               │
│  velocity + geo + adaptive      │  compromise detection           │
├─────────────────────────────────┴─────────────────────────────────┤
│ SPATIAL    GridStamp adapter — proof-of-presence for embodied      │
│            agents (drones, robots). Loose-coupled, fail-closed.    │
├──────────────────────────────────────────────────────────────────┤
│ RAILS  Stripe · Paystack · Lightning · StripeMPP · x402 · AP2    │
│        same PaymentRail interface — drop-in swap, no agent diff   │
└──────────────────────────────────────────────────────────────────┘

Estabilidade dos módulos

O MnemoPay segue semver. Os níveis de estabilidade indicam o quanto a API pública de um módulo pode mudar antes da 2.0 — veja VERSIONING.md para o contrato completo.

Módulo	Importação	Estabilidade	Notas
Memória / recuperação	`@mnemopay/sdk/recall`	Estável	remember · recall · reinforce · forget
Pagamentos	`@mnemopay/sdk`	Estável	charge · settle · refund · dispute, precisão de centavos
Ledger de partidas dobradas	`@mnemopay/sdk`	Estável	débito+crédito=0, encadeado por hash
Identidade (KYA)	`@mnemopay/sdk/identity`	Estável	Ed25519, tokens de capacidade, killswitch
Pontuação de Reputação de Agentes	`@mnemopay/sdk`	Estável	5 componentes, 300–850
Fraude / anomalia	`@mnemopay/sdk`	Estável	velocidade, geo, EWMA, canários
Trilhos de pagamento (Stripe/Paystack/Lightning)	`@mnemopay/sdk/rails`	Estável	uma interface `PaymentRail`
Governança — política	`@mnemopay/sdk/governance/policy`	Estável	`evaluateAction` em menos de um segundo
Governança — cadeia de auditoria	`@mnemopay/sdk/governance/audit-chain`	Estável	fluxo de eventos Merkle, exportação Artigo 12
Governança — carta / Artigo 12	`@mnemopay/sdk/governance`	Estável	escopo da missão + pacotes da Lei de IA da UE
Governança — roteamento de aprovações	`@mnemopay/sdk/governance/approval`	Beta	fila HITL + `routeVerdict`
Governança — taxonomia de risco	`@mnemopay/sdk/governance/risk`	Beta	escada Baixo→Crítico + política predefinida
Governança — ledger de ações	`@mnemopay/sdk/governance/action-ledger`	Beta	registro tipado de "o que o agente fez"
MnemoSkills (habilidades governadas)	`@mnemopay/sdk/skills`	Beta	capacidades versionadas, com permissão e faturáveis — veja examples/08-invoice-collector.ts
Espacial / GridStamp	`@mnemopay/sdk/governance`	Beta	prova de presença, acoplamento frouxo, falha fechada
Trilhos — x402 / AP2 / StripeMPP	`@mnemopay/sdk/rails`	Alfa	padrões emergentes de pagamento entre agentes
Swarm	`@mnemopay/sdk/swarm`	Estável	`spawn` / `gather` / `recombine` / `stop`; 27 testes unitários
CLI do Swarm	`@mnemopay/swarm`	Estável	catálogo listar/instalar/demo
BrowserSwarm / voz	`@mnemopay/sdk/swarm/browser`	Estável	peer `@mnemopay/browser` opcional

Testes

npm test    # full test suite across 12 files

core.test.ts — memória, pagamentos, ciclo de vida, pontuação de reputação, comportamental, Merkle, EWMA, canários, sequências, selos
fraud.test.ts — velocidade, anomalia, taxas, disputas, detecção de replay
geo-fraud.test.ts — sinais geo, confiança, sanções
identity.test.ts — KYA, tokens, permissões
production-100k.test.ts — 100 mil operações, 10 agentes concorrentes, verificação de cadeia de hash, zero desvio
stress-200k.test.ts — estresse de 200 mil no mundo real: 50 agentes, tráfego em rajadas, condições de corrida, tempestades de reembolso, detecção de vazamento de memória
ledger.test.ts — partidas dobradas, reconciliação
network.test.ts — multi-agente, negócios, cadeias de suprimentos
paystack.test.ts — trilho, webhooks, transferências
stress.test.ts — precisão de 1000 ciclos, operações paralelas
recall.test.ts — busca semântica, decaimento, reforço

Licença

Apache License 2.0 — veja LICENSE.

Atribuições de terceiros

O caminho de gravação de observação de entidades em src/recall/observations.ts (resumos consolidados por entidade, regeneração com debounce, rollups que abrangem sessões) é derivado de vectorize-io/hindsight (MIT, Copyright (c) 2025 Vectorize AI, Inc.). O aviso upstream completo é preservado em NOTICE e no cabeçalho do arquivo portado.

Avisos de marca registrada e regulatórios

Pontuação de Reputação de Agentes é um sistema de pontuação de confiabilidade para agentes de software autônomos, não para relatórios de crédito ao consumidor. Ele não produz um relatório de consumidor conforme definido pela Fair Credit Reporting Act (FCRA) e não é regulamentado pela FCRA. O MnemoPay não é uma agência de relatórios de consumo.

O MnemoPay não é um banco, transmissor de dinheiro ou seguradora, e não mantém depósitos de clientes. Os pagamentos são liquidados por meio de trilhos de pagamento de terceiros (Stripe, Paystack, Lightning Network) — o MnemoPay é um software que se conecta a esses trilhos em nome dos desenvolvedores, não uma instituição financeira. "FICO" é uma marca registrada da Fair Isaac Corporation. O MnemoPay e seu módulo de Agent Reputation Scoring não são afiliados, endossados ou derivados da Fair Isaac Corporation. Os nomes de exportação AgentCreditScore e AgentFICO são aliases obsoletos mantidos para compatibilidade retroativa com versões beta anteriores e serão removidos em uma futura versão principal.

Construído por Jeremiah Omiagbo

MnemoPay

Documentação

MnemoPay

Latência de governança (invariante de sub-segundo)

Trilhos nativos

Imports de subpath para consumidores menores e mais seguros

Swarm (estável — v1.11+)

BrowserSwarm — fan-out nativo de sessões de navegador (estável desde 1.11.0)

Middleware somente auditoria — .audit(client) com streaming + cadeia em disco (1.11.0-alpha.0)

Construindo um servidor MCP? Comece aqui.

O Que Torna MnemoPay Diferente

Agent Reputation Scoring

Motor de Finanças Comportamentais

Integridade de Memória (Árvore de Merkle)

Detecção de Anomalias (EWMA + Fingerprinting Comportamental + Canários)

Memória (Base de Conhecimento Composta)

Escolhendo um adaptador de persistência

Sequências de Reputação e Selos

Ledger Encadeado por Hash

Pagamentos (partidas dobradas com precisão de centavos)

Identidade (Conformidade KYA)

Detecção de Fraude (nível ML)

Comércio Multi-Agente

Integração com o Claude Agent SDK

Cache de prompt de 1 hora em resultados de recuperação

Atribuição de custo por subagente

Trilhos de Pagamento

Stripe — cobranças reais em cartão com clientes salvos

Servidor MCP

Middleware

Arquitetura

Estabilidade dos módulos

Testes

Licença

Atribuições de terceiros

Avisos de marca registrada e regulatórios

Middleware somente auditoria — `.audit(client)` com streaming + cadeia em disco (1.11.0-alpha.0)