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

Commands

All Continuity Commands

Includes all commands from the base Continuity skill:

mlp-continuity reflect [--session <transcript>]
mlp-continuity questions [--limit 5]
mlp-continuity status
mlp-continuity greet
mlp-continuity resolve <question-id>

MLP-Specific Commands

# 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 <envelope-cid>

# Generate a context pack for session initialization
mlp-continuity context-pack [--intent general_session]

# Export identity kernel
mlp-continuity export-identity <output-path>

# Import identity kernel from another platform
mlp-continuity import-identity <input-path>

# Sync local memories to MLP storage
mlp-continuity sync

# Show MLP storage status
mlp-continuity mlp-status

Configuration

Environment Variables

# 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)

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

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

const result = await skill.onSessionEnd(session);
// Returns: { memories_stored, questions_generated, envelope_cids }

Multi-Agent Configuration

Add to your openclaw.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

Example: Full Reflection + Storage

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

# 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 — Core reflection library
• MLP Storage — Encrypted storage layer
• Continuity-Only Skill — Local storage without MLP