MnemoPay

Capa de confianza y reputación para agentes de IA que manejan dinero. Puntaje de crédito del agente (300-850), libro mayor encadenado por hash, finanzas conductuales, canales de pago reales (Stripe, Paystack, Lightning), compras autónomas con depósito en garantía.

GitHub

Prueba este MCPPatrocinado

Documentación

MnemoPay

La capa de gobernanza para agentes de IA que manejan dinero. Alcance de misión impulsado por carta, aplicación de presupuesto FiscalGate, paquetes de auditoría del Artículo 12 de la Ley de IA de la UE, Puntuación de reputación de agente (300-850) y una cadena MerkleAudit a prueba de manipulación — en cada rail de pago que un agente tocará jamás.

MnemoPay se sitúa por encima del rail (Stripe, Paystack, Lightning, Stripe MPP, x402, Google AP2) y por debajo del runtime del agente (LangChain, CrewAI, Claude Agent SDK, tu propio bucle). El rail mueve el dinero. El runtime decide. MnemoPay declara las reglas, aplica el presupuesto y produce la evidencia.

npm install @mnemopay/sdk

¿Nuevo aquí? Empieza en docs/QUICKSTART.md — 60 segundos, tres pasos, código funcional.

Documentación: Inicio rápido · Arquitectura · Permisos · Libro de acciones · Integraciones (OpenAI/Anthropic/Gemini/Cohere/Mistral/LangGraph) · Recall · FiscalGate · Paquetes de auditoría (Ley de IA de la UE, Art. 12) · Regla de importación de subruta · Guía de Claude Agent SDK · Bundlers: Vite · Webpack · Bun

Comunidad: LICENSE (Apache 2.0) · CHANGELOG · CONTRIBUTING · CODE_OF_CONDUCT · SECURITY · Discusiones · Buenas primeras incidencias

Comprobantes: Trust hub (entidad, KYB, Apple Team ID, cadena de auditoría del Artículo 12 — verifica en <5 min) · Benchmarks (1M operaciones, 100% de detección adversarial, $0 de desviación del libro mayor) · Python SDK en PyPI (paridad total con los rails 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. Libro mayor encadenado por hash. Paquetes de auditoría Charter / FiscalGate / Artículo 12. 6 rails de pago. Probado bajo estrés con 200K operaciones. Apache 2.0.

Lo que MnemoPay NO es: no es un banco, no es un transmisor de dinero, no es un reemplazo de Stripe, no es un framework de agentes, no es una plataforma de cumplimiento. Es la capa de reglas y evidencia entre el rail y el runtime.

Latencia de gobernanza (invariante de subsegundo)

La «gobernanza en subsegundo» es un invariante probado, no marketing. El banco de pruebas en tests/bench/governance-latency.bench.ts mide cada ruta crítica de gobernanza con vitest bench y emite una línea de resumen [gov-bench] grepeable por escenario. Los números siguientes son percentiles de estado estable de npm run bench:governance (ejecutado en la máquina de desarrollo — tu hardware diferirá; lo que importa es el orden relativo).

Ruta crítica	p50	p95	p99	máquina
`policy.evaluateAction` (Ley de IA de la UE, 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 + hash de cadena)	20 µs	45 µs	150 µs	Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11
`MnemoPayLite.remember()` de extremo a extremo con auto-ancla (Ed25519)	1.0 ms	1.7 ms	2.5 ms	Intel i5-1035G1 @ 1.0 GHz · Node 25.9 · Windows 11

Ambas rutas críticas por evento (evaluateAction, MerkleAudit.record) superan una compuerta de política completa de la Ley de IA de la UE y la escritura en la cadena de auditoría dos órdenes de magnitud dentro de un milisegundo. La ruta remember() de extremo a extremo — incluidos firma Ed25519 + secuencia + emisión de cadena — sigue cómodamente dentro del sobre de «gobernanza en subsegundo» con tres órdenes decimales de margen.

Una especificación de guardia aplicada por CI en tests/governance/latency-invariant.test.ts ejecuta una muestra en modo degradado en cada npm test y falla si el p95 de policy.evaluateAction retrocede más allá de 1 ms, o el de MerkleAudit.record más allá de 5 ms. Los límites están dimensionados para detectar una regresión de ~10x, no para oscilar con la jitter.

Cómo reproducirlo: npm run bench:governance (harness completo de vitest.bench) o npm test -- latency-invariant (verificación vinculada a CI).

Rails nativos

Cada rail incluye la misma interfaz PaymentRail que StripeRail / PaystackRail / LightningRail:

Rail	Qué es
`StripeMPPRail`	Protocolo de pagos automáticos de Stripe — pagos de agentes enrutados como depósitos cripto en la red Tempo a través de la API fijada por Stripe `2026-03-04.preview`
`X402Rail`	Coinbase x402 (revival del HTTP 402) — USDC en Base L2 mediante EIP-3009 `transferWithAuthorization`. Firmante conectable (trae tu propio viem/ethers/noble). Cero dependencias cripto en el SDK.
`GoogleAP2Rail`	Protocolo de pagos de agentes de Google (FIDO Alliance, AP2 v0.2). Mandate VC + Intent VC + liquidación HTTP. Aplicación de políticas previa al vuelo (límites, caducidad, moneda, destinatarios) antes de que se produzca cualquier firma.

Además, el pliegue de gobernanza espacial — attachSpatialEvidence() co-firma la cadena MerkleAudit con prueba de presencia GridStamp para agentes encarnados (drones, robots). Acoplamiento flexible — sin dependencia de runtime gridstamp.

Importaciones de subruta para consumidores más pequeños y seguros

Si solo necesitas un módulo de MnemoPay, importa esa subruta en lugar de la raíz del paquete. Esto mantiene silenciosos a los servidores MCP y otras herramientas stdio, evita arrastrar middleware no utilizado a los bundles y hace obvio el límite de dependencias.

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

Usa la importación raíz cuando quieras la superficie completa del SDK. Usa @mnemopay/sdk/mcp solo cuando estés montando intencionalmente el servidor MCP de MnemoPay.

Swarm (estable — v1.11+)

@mnemopay/sdk/swarm es la pieza que faltaba y que browse.sh publicó como catálogo público de habilidades. La nuestra añade lo que ellos no tienen: cada agente del enjambre lleva un DID, cada acción se precomprueba con FiscalGate contra límites por agente y totales, cada TaskResult se añade a una cadena de auditoría compartida del Artículo 12, y cada invocación de habilidad es facturable a través del mismo libro mayor encadenado por hash que ya usa el resto del SDK.

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

Cuándo usarlo. Cada vez que abrirías N sesiones de navegador en paralelo para atacar un problema — investigación multifuente, triaje de incidencias multiplataforma, estilo A/B de «pregunta a tres agentes, toma la respuesta mayoritaria» — pero quieres un único paquete de auditoría, un único presupuesto y un único lugar donde ocurre la facturación.

Tres estrategias de recombinación (además de la tuya).

first-success — devuelve la salida de la primera tarea ok:true; perfecto para patrones de carrera donde cualquier respuesta vale.
majority-vote — devuelve la salida más común entre las tareas ok:true; perfecto para extracción de hechos donde el consenso importa.
merge-json — fusiona en profundidad cada salida de objeto ok:true con claves ordenadas (determinista entre ejecuciones).
concat — une salidas de cadena con \n en orden de creación.
O pasa cualquier callback (results) => unknown.

Catálogo de habilidades. Los listados públicos viven en mcp.mnemopay.com/skills. El catálogo es intencionalmente pequeño y está marcado con honestidad — las insignias de socio verificado solo aparecen después de firmar una asociación real. Todo lo demás lleva verified: false, status: 'pending-partner' para que sepas exactamente qué nivel de confianza estás obteniendo.

BrowserSwarm — expansión nativa de sesiones de navegador (estable desde 1.11.0)

@mnemopay/sdk/swarm/browser extiende Swarm con una secuencia de pasos tipada (goto / act / extract / screenshot / wait) por tarea y una conexión perezosa a @mnemopay/browser (dependencia opcional entre pares — instalar el SDK NO arrastra Playwright). Cada tarea obtiene su propia sesión de navegador, cada paso añade un evento browser.step a la cadena de auditoría compartida, y un paso que lanza una excepción mata solo esa tarea — las sesiones hermanas siguen ejecutándose.

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

Reporta incidencias en github.com/mnemopay/mnemopay-sdk.

Middleware solo de auditoría — `.audit(client)` con streaming + cadena en disco (1.11.0-alpha.0)

Para widgets de chat y pipelines regulados donde CUALQUIER mutación del prompt es una violación, pero la telemetría del Artículo 12 sigue siendo obligatoria:

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 expone la forma equivalente para OpenAI — chat.completions.create({ stream: true }) se intercepta automáticamente (pasa stream_options: { include_usage: true } para capturar el bloque de uso final).

¿Estás construyendo un servidor MCP? Empieza aquí.

Si estás lanzando un servidor MCP y quieres cobrar por llamada — incluso cantidades de menos de un centavo — MnemoPay está hecho para ti.

Pagos de menos de un centavo mediante el rail Lightning (imposible en Stripe/Paystack por las comisiones)
Medición por herramienta con agent.charge(amount, toolName) — dos líneas de código
Agent Reputation Scoring bloquea automáticamente a los llamadores abusivos — puntuación de reputación de 300-850, nivel gratuito + nivel de pago
Recibos criptográficos que cada usuario puede auditar — sin facturación de «confía en mí, colega»
Gratis indefinidamente para los primeros 10 servidores MCP que lo adopten, sujeto a un aviso por escrito de 90 días ante cualquier cambio futuro (correo con tu repositorio)

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

Inicio de configuración cero → rail Lightning de producción → bloqueo por Agent Reputation Scoring. La misma API.

Qué hace diferente a MnemoPay

Se han invertido $87M en 5 competidores. Ninguno tiene más de 3 de estas 10 características:

Característica	MnemoPay	Mem0 ($24M)	Skyfire ($9.5M)	Kite ($33M)	Payman ($14M)
Memoria persistente	Sí	Sí	No	No	No
Rails de pago (3)	Sí	No	Solo USDC	Stablecoin	Solo banco
Identidad de agente (KYA)	Sí	No	En desarrollo	Passport	No
Puntuación de reputación de agente (300-850)	Sí	No	No	No	No
Finanzas conductuales	Sí	No	No	No	No
Integridad de memoria (Merkle)	Sí	No	No	No	No
Detección de anomalías EWMA	Sí	No	No	No	No
Libro mayor de partida doble	Sí	No	No	No	No
Comercio autónomo	Sí	No	No	No	No
Red multiagente	Sí	No	Parcial	Parcial	No
Puntuación	10/10	1/10	2/10	2/10	1/10

Puntuación de reputación de agente

Un novedoso sistema de puntuación de reputación entre sesiones para agentes de IA. Puntuación de cinco componentes en un rango de 300-850 (familiar para los desarrolladores por el crédito al consumo; MnemoPay no está afiliado a Fair Isaac Corporation ni a ninguna agencia de crédito al consumo):

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	Qué mide
Historial de pagos	35%	Tasa de éxito, disputas, ponderado por actualidad
Utilización de crédito	20%	Gasto vs límite de presupuesto, punto óptimo 10-30%
Antigüedad del historial	15%	Edad de la cuenta, densidad de actividad
Diversidad de comportamiento	15%	Contrapartes, categorías, rango de montos
Registro de fraude	15%	Marcas de fraude, disputas perdidas, advertencias

Rango de puntuación	Calificación	Nivel de confianza	Tasa de comisión
800-850	Excepcional	Confianza total	1.0%
740-799	Muy bueno	Confianza alta	1.3%
670-739	Bueno	Estándar	1.5%
580-669	Aceptable	Reducida	1.9%
300-579	Pobre	Mínima + HITL	2.5%

Motor de finanzas conductuales

Economía conductual revisada por pares del premio Nobel Daniel Kahneman y sus colaboradores. Cada parámetro citado a investigación 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 }

Fuentes de investigación: Tversky y Kahneman 1992, Laibson 1997, Thaler y Benartzi 2004, Barber y Odean 2000, Nunes y Dreze 2006, Shiller 2000.

Integridad de memoria (árbol de Merkle)

Memoria a prueba de manipulación. Si alguien inyecta, modifica o elimina los recuerdos de un agente, la raíz de Merkle cambia y lo sabes.

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

Defiende contra: inyección MemoryGraft, eliminación silenciosa, manipulación de contenido, ataques de repetición, ataques de reordenamiento.

Detección de anomalías (EWMA + huella conductual + canarios)

Tres sistemas independientes que detectan 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áticas: mu_t = alpha * x_t + (1 - alpha) * mu_{t-1}, alerta cuando |x_t - mu_t| > k * sigma_t (Roberts 1959, Lucas y Saccucci 1990).

Memoria (base de conocimiento compuesta)

No es una búsqueda RAG tradicional. Las memorias de MnemoPay se acumulan: cada transacción fortalece el contexto asociado, las memorias débiles decaen y las fuertes se consolidan. Es el mismo patrón que Karpathy describe como "LLM Wiki", pero aplicado a pagos y confianza.

Curva de olvido de Ebbinghaus — las memorias decaen naturalmente con el tiempo
Refuerzo hebbiano — las transacciones exitosas fortalecen las memorias asociadas
Bucle de retroalimentación RL — rlFeedback(ids, reward) aplica actualizaciones de importancia EWMA después de las acciones del agente
Consolidación — poda automáticamente memorias débiles, conserva lo que importa
Recuperación semántica — encuentra memorias por relevancia, no solo por recencia
100KB por memoria — almacena contexto rico, no solo cadenas

// 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

Elegir un adaptador de persistencia

La recuperación está respaldada por un PersistenceAdapter conectable. Elige según la forma de despliegue:

Adaptador	Infraestructura	Mejor para	Importación
`MemoryAdapter` (predeterminado)	ninguna	desarrollo, pruebas, agentes efímeros	integrado
`SQLiteAdapter`	un archivo (`better-sqlite3`)	nodo único, local-first, edge	`@mnemopay/sdk/storage`
`PostgresAdapter` / `NeonAdapter`	Postgres + pgvector	producción alojada/multinodo (Neon, Supabase, RDS/Aurora, Cloud SQL)	`@mnemopay/sdk/recall/postgres`

PostgresAdapter y NeonAdapter son la misma implementación respaldada por pgvector — "Neon" es solo Postgres alojado; usa el nombre que se ajuste a tu infraestructura.

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

El esquema (una columna vector(384) + índice HNSW de coseno) se crea automáticamente en la primera escritura. Para gestionarlo con tu propia herramienta de migraciones, ejecuta el DDL desde postgresMigrationSql(table?, dimensions?) y pasa skipBootstrap: true. Requiere la dependencia opcional: npm install pg.

Racha de Reputación e Insignias

Los agentes ganan confianza con el tiempo. Los asentamientos exitosos consecutivos construyen rachas que desbloquean insignias y reducen tarifas.

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

Insignia	Requisito
Primer Asentamiento	Completar 1 asentamiento
Racha 10	10 asentamientos consecutivos
Racha 50	50 asentamientos consecutivos
Volumen $1K	$1,000+ asentados en total
Volumen $10K	$10,000+ asentados en total
Registro Perfecto	100+ asentamientos, 0 disputas

Las rachas se reinician con reembolsos o disputas. Las bonificaciones por racha acumulan reputación hasta +10%.

Libro Mayor Encadenado por Hash

Cada entrada del libro mayor se enlaza con la anterior mediante una cadena de hash SHA-256. Si se modifica cualquier entrada, la cadena se rompe y verify() lo detecta al instante.

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

Combinado con integridad Merkle en memorias y HMAC en transacciones, MnemoPay te ofrece tres sistemas independientes de detección de manipulación.

Pagos (doble entrada con precisión de centavos)

Contabilidad de doble entrada — cada débito tiene un crédito, siempre cuadra a cero
Flujo de depósito en garantía — cobro -> retención -> asentamiento -> reembolso (misma forma que Stripe/Square)
Tarifas por niveles de volumen — 1.9% / 1.5% / 1.0% según volumen acumulado
3 vías de pago — Paystack (África), Stripe (global), Lightning (BTC)
Matemática entera de precisión de centavos — probada con 200,000 transacciones en 50 agentes concurrentes, cero desviación

Identidad (Cumplimiento KYA)

Identidad criptográfica — pares de claves HMAC-SHA256, protección contra repetición
Tokens de capacidad — permisos con límites de gasto
Listas blancas de contrapartes — restringe con quién puede transaccionar el agente
Interruptor de apagado — revoca todos los tokens al instante

Detección de Fraude (grado ML)

Controles de velocidad — límites por minuto/hora/día
Isolation Forest — detección de anomalías ML no supervisada
Mejorado con geo — seguimiento de país, detección de saltos rápidos, sanciones OFAC
Motor adaptativo — AIMD asimétrico, anti-juego, disyuntor, detección de deriva PSI

Comercio Multi-Agente

CommerceEngine — compras autónomas con mandatos, depósito en garantía, callbacks de aprobación
MnemoPayNetwork — registra agentes, ejecuta acuerdos, contexto de memoria compartida
Cadenas de suministro — cadenas de agentes de 10 pasos, mercados de 100 agentes, todo probado

Integración con el SDK de Claude Agent

Dos primitivas construidas específicamente para el patrón del SDK de Claude Agent donde un orquestador Opus genera subagentes Sonnet/Haiku.

Caché de prompt de 1 hora en resultados de recuperación

Cuando alimentas la recuperación de MnemoPay en un prompt de sistema de Claude, usa formatForClaudeCache() para emitir un bloque de contenido con cache_control: { type: "ephemeral", ttl: 3600 }. La API de Anthropic almacena en caché ese prefijo hasta por 1 hora; las lecturas de caché se facturan aproximadamente al 10% de la tasa de entrada normal. Con prefijos de recuperación estables y una caché cálida de 1h, los usuarios han observado ahorros en el rango típico del 85-92% en la porción de recuperación de los tokens de entrada — tus resultados reales dependen de la frecuencia de llamadas y la estabilidad del conjunto de memorias.

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 }],
});

El texto serializado se ordena por id de memoria para que conjuntos de memorias idénticos produzcan salida byte-idéntica — requerido para que el prefijo de caché acierte en turnos posteriores.

Atribución de costos por subagente

Rastrea cuánto gastó cada subagente en un pipeline multi-agente — registrado como pares de libro mayor de doble entrada para que se mantenga limpio en auditoría.

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");

Tabla de precios utilizada: tarifas de lista de Anthropic 2026 (Opus 4.7 $5/$25/M, Sonnet 4.6 $3/$15/M, Haiku 4.5 $1/$5/M; lecturas de caché 0.1×, escrituras de 1h 2×). Actualiza MODEL_PRICING en src/subagent-cost.ts si las tarifas cambian.

Ver docs/agent-sdk-guide.md para un recorrido completo de integración.

Vías de Pago

Cada vía implementa la misma interfaz PaymentRail — createHold / capturePayment / reversePayment. Cambia de vía sin tocar el código del agente.

Vía	Cobertura
`StripeRail`	Tarjetas (USD, EUR, GBP, +)
`PaystackRail`	África (NGN, GHS, ZAR, KES)
`LightningRail`	Micropagos BTC de sub-centavos
`StripeMPPRail`	Depósitos cripto en Tempo vía Stripe MPP
`X402Rail`	USDC en Base vía EIP-3009 transferWithAuthorization
`GoogleAP2Rail`	Asentamiento basado en mandatos 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 — cargos reales con clientes guardados

Flujo de extremo a extremo para cobrar la tarjeta guardada de un usuario sin intervención del 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);

Paystack soporta el mismo patrón vía 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 herramientas predeterminado: essentials (14 herramientas, ~1K tokens). Uno de los servidores MCP más ligeros que puedes instalar — MnemoPay solo carga memoria + billetera + tx por defecto para no gravar el presupuesto de contexto de tu agente.

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

¿Necesitas más? Actívalo explícitamente:

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. Alias: essentials (predeterminado), agent, all. También configurable vía variable de entorno MNEMOPAY_TOOLS.

Cambio importante en v1.3.0: el predeterminado era all, ahora es essentials. Si dependías de que commerce/hitl/webhooks/fico/security estuvieran disponibles sin una bandera, pasa --tools=all o --tools=agent. Ver CHANGELOG.

Middleware

Proxies de inserción que hacen invisible la recuperación: cada llamada de chat inyecta automáticamente las memorias principales como contexto de sistema y almacena el intercambio después. Misma forma Middleware.wrap(client, agent) en cada proveedor.

// 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";

Arquitectura

Diagrama completo de pila y 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   │
└──────────────────────────────────────────────────────────────────┘

Estabilidad de módulos

MnemoPay sigue semver. Los niveles de estabilidad te indican cuánto puede cambiar la API pública de un módulo antes de 2.0 — ver VERSIONING.md para el contrato completo.

Módulo	Importación	Estabilidad	Notas
Memoria / recuperación	`@mnemopay/sdk/recall`	Estable	recordar · recuperar · reforzar · olvidar
Pagos	`@mnemopay/sdk`	Estable	cobrar · asentar · reembolsar · disputar, precisión de centavos
Libro mayor de doble entrada	`@mnemopay/sdk`	Estable	débito+crédito=0, encadenado por hash
Identidad (KYA)	`@mnemopay/sdk/identity`	Estable	Ed25519, tokens de capacidad, interruptor de apagado
Puntuación de Reputación de Agente	`@mnemopay/sdk`	Estable	5 componentes, 300–850
Fraude / anomalía	`@mnemopay/sdk`	Estable	velocidad, geo, EWMA, canarios
Vías de pago (Stripe/Paystack/Lightning)	`@mnemopay/sdk/rails`	Estable	una interfaz `PaymentRail`
Gobernanza — política	`@mnemopay/sdk/governance/policy`	Estable	`evaluateAction` en sub-segundo
Gobernanza — cadena de auditoría	`@mnemopay/sdk/governance/audit-chain`	Estable	flujo de eventos Merkle, exportación Artículo 12
Gobernanza — carta / Artículo 12	`@mnemopay/sdk/governance`	Estable	alcance de misión + paquetes de IA de la UE
Gobernanza — enrutamiento de aprobaciones	`@mnemopay/sdk/governance/approval`	Beta	cola HITL + `routeVerdict`
Gobernanza — taxonomía de riesgo	`@mnemopay/sdk/governance/risk`	Beta	escalera Bajo→Crítico + política preestablecida
Gobernanza — libro de acciones	`@mnemopay/sdk/governance/action-ledger`	Beta	registro tipado de "qué hizo el agente"
MnemoSkills (habilidades gobernadas)	`@mnemopay/sdk/skills`	Beta	capacidades versionadas, con permisos, facturables — ver examples/08-invoice-collector.ts
Espacial / GridStamp	`@mnemopay/sdk/governance`	Beta	prueba de presencia, acoplado suelto, fallo cerrado
Vías — x402 / AP2 / StripeMPP	`@mnemopay/sdk/rails`	Alfa	estándares emergentes de pago para agentes
Enjambre	`@mnemopay/sdk/swarm`	Estable	`spawn` / `gather` / `recombine` / `stop`; 27 pruebas unitarias
CLI de Enjambre	`@mnemopay/swarm`	Estable	catálogo listar/instalar/demo
BrowserSwarm / voz	`@mnemopay/sdk/swarm/browser`	Estable	par opcional `@mnemopay/browser`

Pruebas

npm test    # full test suite across 12 files

core.test.ts — memoria, pagos, ciclo de vida, puntuación de reputación, comportamiento, Merkle, EWMA, canarios, rachas, insignias
fraud.test.ts — velocidad, anomalía, tarifas, disputas, detección de repetición
geo-fraud.test.ts — señales geo, confianza, sanciones
identity.test.ts — KYA, tokens, permisos
production-100k.test.ts — 100K operaciones, 10 agentes concurrentes, verificación de cadena de hash, cero desviación
stress-200k.test.ts — estrés de 200K en mundo real: 50 agentes, tráfico ráfaga, condiciones de carrera, tormentas de reembolso, detección de fugas de memoria
ledger.test.ts — doble entrada, conciliación
network.test.ts — multi-agente, acuerdos, cadenas de suministro
paystack.test.ts — vías, webhooks, transferencias
stress.test.ts — precisión de 1000 ciclos, operaciones paralelas
recall.test.ts — búsqueda semántica, decaimiento, refuerzo

Licencia

Licencia Apache 2.0 — ver LICENSE.

Atribuciones de terceros

La ruta de escritura de observación de entidades en src/recall/observations.ts (resúmenes consolidados por entidad, regeneración con debounce, acumulaciones que abarcan sesiones) se deriva de vectorize-io/hindsight (MIT, Copyright (c) 2025 Vectorize AI, Inc.). El aviso completo de upstream se conserva en NOTICE y en el encabezado del archivo portado.

Avisos de marca registrada y regulatorios

Puntuación de Reputación de Agente es un sistema de puntuación de confiabilidad para agentes de software autónomos, no para informes de crédito al consumidor. No produce un informe de consumidor según lo define la Ley de Informes de Crédito Justos (FCRA) y no está regulado bajo la FCRA. MnemoPay no es una agencia de informes de consumidores.

MnemoPay no es un banco, transmisor de dinero o aseguradora, y no mantiene depósitos de clientes. Los pagos se asientan a través de vías de pago de terceros (Stripe, Paystack, Lightning Network) — MnemoPay es software que se conecta a esas vías en nombre de los desarrolladores, no una institución financiera. "FICO" es una marca comercial registrada de Fair Isaac Corporation. MnemoPay y su módulo de Puntuación de Reputación de Agentes no están afiliados, respaldados ni derivados de Fair Isaac Corporation. Los nombres de exportación AgentCreditScore y AgentFICO son alias obsoletos que se mantienen por compatibilidad con versiones beta anteriores y se eliminarán en una futura versión principal.

Creado por Jeremiah Omiagbo

MnemoPay

Documentación

MnemoPay

Latencia de gobernanza (invariante de subsegundo)

Rails nativos

Importaciones de subruta para consumidores más pequeños y seguros

Swarm (estable — v1.11+)

BrowserSwarm — expansión nativa de sesiones de navegador (estable desde 1.11.0)

Middleware solo de auditoría — .audit(client) con streaming + cadena en disco (1.11.0-alpha.0)

¿Estás construyendo un servidor MCP? Empieza aquí.

Qué hace diferente a MnemoPay

Puntuación de reputación de agente

Motor de finanzas conductuales

Integridad de memoria (árbol de Merkle)

Detección de anomalías (EWMA + huella conductual + canarios)

Memoria (base de conocimiento compuesta)

Elegir un adaptador de persistencia

Racha de Reputación e Insignias

Libro Mayor Encadenado por Hash

Pagos (doble entrada con precisión de centavos)

Identidad (Cumplimiento KYA)

Detección de Fraude (grado ML)

Comercio Multi-Agente

Integración con el SDK de Claude Agent

Caché de prompt de 1 hora en resultados de recuperación

Atribución de costos por subagente

Vías de Pago

Stripe — cargos reales con clientes guardados

Servidor MCP

Middleware

Arquitectura

Estabilidad de módulos

Pruebas

Licencia

Atribuciones de terceros

Avisos de marca registrada y regulatorios

Middleware solo de auditoría — `.audit(client)` con streaming + cadena en disco (1.11.0-alpha.0)