# Mlp Continuity > Full-stack memory continuity with MLP storage. Combines the Continuity Framework's reflection capabilities with encrypted IPFS/Pinata storage via the Memory Ledger Protocol. Use when this capability is needed. - Skill: `tomevault-io/mlp-continuity` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add tomevault-io/mlp-continuity` - Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/mlp-continuity/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: tomevault-io (https://skillmd.com/u/tomevault-io) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/tomevault-io/mlp-continuity --- # MLP Continuity - Full Stack Integration Combines asynchronous reflection with sovereign, encrypted memory storage via the Memory Ledger Protocol. ## Architecture ``` ┌─────────────────────────────────────────────────────────────┐ │ Full Stack Continuity │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ Continuity Framework (Reflection) │ │ │ │ Classifier → Scorer → Generator → Integration │ │ │ └───────────────────────┬─────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ MLP Storage Layer │ │ │ │ Encryption → IPFS → Envelopes │ │ │ └───────────────────────┬─────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ Decentralized Storage │ │ │ │ IPFS / Pinata / Arweave │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ## Features | Feature | Reflection-Only | Full Stack | |---------|-----------------|------------| | Memory extraction | ✓ | ✓ | | Confidence scoring | ✓ | ✓ | | Question generation | ✓ | ✓ | | Local markdown storage | ✓ | ✓ | | Encrypted storage | ✗ | ✓ | | IPFS/Pinata persistence | ✗ | ✓ | | Cross-platform portability | ✗ | ✓ | | Cryptographic attestations | ✗ | ✓ | | Identity kernel integration | ✗ | ✓ | | Context pack generation | ✗ | ✓ | ## Commands ### All Continuity Commands Includes all commands from the base Continuity skill: ```bash mlp-continuity reflect [--session ] mlp-continuity questions [--limit 5] mlp-continuity status mlp-continuity greet mlp-continuity resolve ``` ### MLP-Specific Commands ```bash # Store a memory to IPFS with encryption mlp-continuity store "Memory content" --type fact --tags "tag1,tag2" # Load a memory from IPFS mlp-continuity load # Generate a context pack for session initialization mlp-continuity context-pack [--intent general_session] # Export identity kernel mlp-continuity export-identity # Import identity kernel from another platform mlp-continuity import-identity # Sync local memories to MLP storage mlp-continuity sync # Show MLP storage status mlp-continuity mlp-status ``` ## Configuration ### Environment Variables ```bash # Continuity settings export CONTINUITY_MEMORY_DIR=~/clawd/memory export CONTINUITY_IDLE_THRESHOLD=1800 export CONTINUITY_QUESTION_LIMIT=3 # MLP storage settings export MLP_CONFIG_PATH=~/.openclaw/mlp-config.yaml export PINATA_JWT=your_pinata_jwt_token export PINATA_GATEWAY=your_gateway.mypinata.cloud ``` ### Config File (~/.openclaw/mlp-config.yaml) ```yaml mlp_version: "0.2" storage: provider: pinata jwt: ${PINATA_JWT} gateway: ${PINATA_GATEWAY} # Or use local for development: # provider: local # path: ~/.openclaw/mlp-blobs encryption: algorithm: "XChaCha20-Poly1305" key_path: ~/.openclaw/keys identity: kernel_path: ~/.openclaw/identity-kernel.yaml epoch_duration: "P30D" ``` ## Workflow ### Session Start 1. Load IdentityKernel from MLP storage 2. Generate ContextPack with relevant memories 3. Load pending questions from continuity store 4. Surface questions in greeting ```javascript const result = await skill.onSessionStart(); // Returns: { contextPack, questions, identity } ``` ### Session End 1. Run Continuity reflection (classifier → scorer → generator) 2. Encrypt new memories 3. Store encrypted blobs to IPFS 4. Create MLP envelopes with attestations 5. Save questions for next session ```javascript const result = await skill.onSessionEnd(session); // Returns: { memories_stored, questions_generated, envelope_cids } ``` ## Multi-Agent Configuration Add to your openclaw.json: ```json { "agents": { "list": [ { "id": "main" }, { "id": "continuity-classifier", "workspace": "~/clawd/continuity-agents/classifier", "model": "anthropic/claude-sonnet-4", "tools": { "allow": ["read"] } }, { "id": "continuity-scorer", "workspace": "~/clawd/continuity-agents/scorer", "model": "anthropic/claude-sonnet-4", "tools": { "allow": ["read"] } }, { "id": "continuity-generator", "workspace": "~/clawd/continuity-agents/generator", "model": "anthropic/claude-sonnet-4", "tools": { "allow": ["read"] } } ] } } ``` ## Memory Flow ``` Conversation │ ▼ ┌────────────────────────────────┐ │ Continuity Reflection │ │ - Classify memories │ │ - Score confidence │ │ - Generate questions │ └────────────────────────────────┘ │ ▼ ┌────────────────────────────────┐ │ MLP Storage Bridge │ │ - Convert to MLP format │ │ - Encrypt content │ │ - Sign with identity │ └────────────────────────────────┘ │ ▼ ┌────────────────────────────────┐ │ IPFS/Pinata │ │ - Store encrypted blob │ │ - Get CID │ └────────────────────────────────┘ │ ▼ ┌────────────────────────────────┐ │ MLP Envelope │ │ - Create envelope │ │ - Add attestations │ │ - Store to ledger │ └────────────────────────────────┘ ``` ## Trust Model | Component | Trust Level | Notes | |-----------|-------------|-------| | Your agent | Trusted | Signs memories with identity | | Continuity sub-agents | Partial | Read-only, no external access | | Storage (IPFS) | Untrusted | Only sees encrypted data | | Platform | Untrusted | No access to decryption keys | ## Example: Full Reflection + Storage ```javascript import { MLPContinuity } from 'mlp-continuity'; const skill = new MLPContinuity(); await skill.init(); // Run reflection on session const reflection = await skill.reflect(conversation); // → Extracts memories, scores confidence, generates questions // Memories are automatically encrypted and stored // → Returns envelope CIDs for each memory // Next session const context = await skill.generateContextPack(); // → Loads identity kernel, decrypts relevant memories, compiles pack ``` ## Compatibility - **Node.js**: >= 18.0.0 - **MLP Spec**: v0.2 - **Continuity Framework**: v1.0.0 - **Storage**: Pinata, IPFS, local (dev mode) ## Migration from Continuity-Only If you started with the continuity-only skill (`skills/openclaw/continuity/`): ```bash # Sync existing local memories to MLP storage mlp-continuity sync --source ~/clawd/memory # This will: # 1. Read all memories from MEMORY.md # 2. Encrypt each memory # 3. Store to IPFS # 4. Create MLP envelopes # 5. Keep local copies as backup ``` ## Related - [Continuity Framework](../../../continuity/) — Core reflection library - [MLP Storage](../../../mlp-storage/) — Encrypted storage layer - [Continuity-Only Skill](../continuity/) — Local storage without MLP --- > Source: [Riley-Coyote/memory-ledger-protocol-v0.2](https://github.com/Riley-Coyote/memory-ledger-protocol-v0.2) — distributed by [TomeVault](https://tomevault.io).