Migrating from OpenClaw

A detailed guide for users coming from the OpenClaw/ClaudeClaw Telegram-based agent system.

Architecture Comparison

OpenClaw routes messages through a Telegram bot into Claude via the Agent SDK. Super Agents gives Claude direct access to everything through the CLI.

  ┌─ OpenClaw Architecture ──────────────────────────────────────────────┐
  │                                                                      │
  │  Telegram ──▶ Auth Layer ──▶ Media Handler ──▶ Memory Injection      │
  │     ▲                                              (SQLite)          │
  │     │                                                │               │
  │     │                                                ▼               │
  │  Response Conversion ──── Agent SDK (subprocess)                     │
  │                                                                      │
  └──────────────────────────────────────────────────────────────────────┘

  ┌─ Super Agents Architecture ──────────────────────────────────────────┐
  │                                                                      │
  │  Terminal / Chat ──▶ Claude Code CLI ──▶ Commands / Agents / Skills  │
  │                           ▲                      │                   │
  │                           │                      ▼                   │
  │                      Knowledge Vault ── Scripts + APIs               │
  │                      (PARA)                                          │
  │                                                                      │
  └──────────────────────────────────────────────────────────────────────┘

Key Differences

Component Mapping

Here’s how each OpenClaw component maps to Super Agents:

1. Telegram Bot (Input Layer)

OpenClaw: All interaction goes through Telegram. Messages are received, authenticated, and forwarded to Claude.

Super Agents: Primary interaction is through the terminal (Claude Code CLI). However, you can keep Telegram as an input layer if you want mobile access. The key change is that Telegram is no longer the only interface.

Migration: Optional. You can keep your Telegram bot running as a secondary input channel, or switch fully to terminal.

2. SQLite Memory (3-Layer Memory System)

OpenClaw: Three memory layers:

• Session context — current conversation thread
• Semantic memory — long-term facts and preferences stored in SQLite
• Episodic memory — past interaction summaries

Super Agents: Memory lives in the vault as structured markdown:

• Session context -> Claude Code’s built-in conversation memory
• Semantic memory -> Self_Context files (identity, values, preferences) + AGENT_GUIDE.md
• Episodic memory -> JSONL session logs + vault tracking files

  ┌─ OpenClaw Memory ──────────────────┐  ┌─ Super Agents Memory ──────────────┐
  │                                    │  │                                    │
  │  Session Context                   │  │  Conversation History              │
  │  Semantic Memory   ──▶  SQLite DB  │  │  Self_Context + AGENT_GUIDE        │
  │  Episodic Memory                   │  │  JSONL Logs + Vault Files          │
  │                          │         │  │                   │                │
  │                          ▼         │  │                   ▼                │
  │                   Injected per     │  │          Layered context           │
  │                   message          │  │          loading on demand         │
  │                                    │  │                                    │
  └────────────────────────────────────┘  └────────────────────────────────────┘

Migration steps:

1. Export your SQLite semantic memories to markdown
2. Organize them into Self_Context files by topic
3. Convert episodic memories to vault log files or discard (NightCrew will build new ones)

3. Memory Injection (Context Before Each Message)

OpenClaw: Before each message reaches Claude, relevant memories are retrieved from SQLite and injected into the prompt.

Super Agents: Context loading is explicit via /contxt at session start, plus automatic CLAUDE.md injection. This is more transparent and controllable.

Key difference: OpenClaw injects silently per-message. Super Agents loads explicitly per-session. You see exactly what context is loaded and can adjust it.

4. Agent SDK Subprocess

OpenClaw: Each message spawns a Claude Code subprocess with full tool access. The subprocess runs, produces output, and exits.

Super Agents: Claude Code runs as a persistent, interactive session. You get:

• Full tool access (same as OpenClaw’s subprocess)
• Persistent conversation context within a session
• Slash commands, agents, and skills (not just raw prompts)
• Hook system for pre/post validation

Migration: No action needed. Claude Code is the native runtime.

5. Media Handling

OpenClaw: Photos, voice messages, and documents sent via Telegram are processed through a media handler (transcription, OCR, etc.).

Super Agents: Media processing happens through Python scripts and direct file access:

• Photos: photo_triage.py or direct file path
• Voice: Transcription scripts
• Documents: PDF split + vault storage
• Claude Code can read images directly

Migration Checklist

Phase 1: Foundation (Day 1)

• Install Claude Code CLI if not already installed
• Create your vault structure (follow Setup Guide)
• Create ~/.claude/CLAUDE.md with your global rules
• Create AGENT_GUIDE.md as your routing index

Phase 2: Memory Migration (Day 1-2)

• Export OpenClaw SQLite semantic memories
• Convert memories to markdown files in Self_Context
• Create master_context.md hub file
• Test context loading with /contxt

Phase 3: Workflow Migration (Day 2-3)

• List all workflows you used via Telegram
• Create slash commands for frequently used workflows
• Set up key agents for your most common tasks
• Test each workflow through Claude Code CLI

Phase 4: Automation (Day 3-5)

• Identify scheduled tasks from your OpenClaw setup
• Convert to LaunchAgents (see Scheduling)
• Set up NightCrew or equivalent nightly pipeline
• Verify automations run on schedule

Phase 5: Optional Telegram (Anytime)

• Decide if you want to keep Telegram as a secondary input
• If yes: point your Telegram bot at Claude Code instead of Agent SDK
• If no: decommission the bot

What You Gain

Moving from OpenClaw to Super Agents, you gain:

• Full PARA vault — structured knowledge base instead of flat SQLite
• A large command library — pre-built workflows for common tasks
• Specialized agents — not just a generic assistant
• Thinking tools — challenge, discover, plan, and learn
• Scheduled automation — LaunchAgents for hands-off data collection
• Multi-domain context — one system for coding, finance, health, content, and more
• Transparent context — you see exactly what the agent knows

What’s Different

Be prepared for these workflow changes: