MnemoPay v1.4.0: Long-Term Memory and Financial Rails for AI Agents

MnemoPay v1.4.0: 77.2% on LongMemEval, 1M-op stress test, and what the architecture actually looks like

MnemoPay v1.4.0 addresses the limitations of short-history agent benchmarks by achieving a 77.2% oracle score on LongMemEval. The system successfully passed a 1-million operation production stress test with zero data corruption across complex, multi-session histories.

Why This Matters

Standard agent memory often fails when faced with conflicting information over long histories because flat retrieval systems return contradictory facts without temporal awareness. This architectural flaw leads to behavioral drift, where memory state shifts cause agents to deviate from their instructions without explicit changes to their code.

By implementing Ebbinghaus decay and EWMA anomaly detection, MnemoPay provides a mathematical framework to maintain memory salience and detect performance degradation. This is critical for agents with financial stakes, where auditable history and tamper-evident memory chains are required to verify why specific spending decisions were made.

Key Insights

• MnemoPay uses Ebbinghaus decay curves and Hebbian learning (2026) to prioritize recency and retrieval frequency over flat key-value storage.
• EWMA (Exponentially Weighted Moving Average) anomaly detection identifies behavioral drift using a 0.15 smoothing factor to flag pattern deviations.
• Merkle hashing provides tamper-evident memory history, ensuring all ‘forget’ operations are auditable for financial compliance.
• Portable agent credit scores (300-850) are embedded in JWTs to allow agents to carry reputation across different host systems.
• HMAC-SHA256-signed receipts provide a cryptographically verifiable trail for payments processed via Stripe, Paystack, and Lightning rails.

Working Examples

Simplified EWMA anomaly detection for monitoring agent behavioral drift.

const alpha = 0.15;
ewma = alpha * observed + (1 - alpha) * ewma;
const deviation = Math.abs(observed - ewma) / ewma;
if (deviation > ANOMALY_THRESHOLD) {
  await flagAnomaly(agentId, { observed, ewma, deviation });
}

Storing decay-weighted memory and executing cryptographically signed payments.

import { MnemoPay } from '@mnemopay/sdk';
const client = new MnemoPay({ apiKey: process.env.MNEMOPAY_API_KEY });

await client.memory.store(agentId, {
  content: 'user prefers async communication over meetings',
  context: 'onboarding-session-3',
  importance: 0.85
});

const memories = await client.memory.recall(agentId, {
  query: 'user communication preferences',
  limit: 5
});

const payment = await client.payments.charge({
  agentId,
  amount: 4.99,
  currency: 'usd',
  rail: 'stripe',
  memo: 'API call batch — vector search'
});

Retrieving the portable agent credit score (300-850) from the identity service.

const { score, tier, flags } = await client.identity.getCreditScore(agentId);

Practical Applications

• Audit-ready financial agents: Use Merkle-hashed memory chains to provide a verifiable trail for budget management. Pitfall: Using non-hashed storage makes it impossible to prove memory wasn’t tampered with post-transaction.
• Long-term preference management: Implement Ebbinghaus decay to resolve conflicts between old and new user data. Pitfall: Flat retrieval returns stale preferences, causing agents to ignore recent user updates.
• Reputation-based agent access: Utilize portable credit scores to gate access to high-value APIs. Pitfall: Resetting agent reputation on every new system prevents the scaling of trusted autonomous behavior.

References:

• https://mnemopay.com