Continuous Claude
A persistent, learning, multi-agent development environment built on Claude Code
Continuous Claude transforms Claude Code into a continuously learning system that maintains context across sessions, orchestrates specialized agents, and eliminates wasting tokens through intelligent code analysis.
Table of Contents
Why Continuous Claude?
Claude Code has a compaction problem: when context fills up, the system compacts your conversation, losing nuanced understanding and decisions made during the session.
Continuous Claude solves this with:
| Problem |
Solution |
| Context loss on compaction |
YAML handoffs - more token-efficient transfer |
| Starting fresh each session |
Memory system recalls + daemon auto-extracts learnings |
| Reading entire files burns tokens |
5-layer code analysis + semantic index |
| Complex tasks need coordination |
Meta-skills orchestrate agent workflows |
| Repeating workflows manually |
109 skills with natural language triggers |
The mantra: Compound, don't compact. Extract learnings automatically, then start fresh with full context.
Why "Continuous"? Why "Compounding"?
The name is a pun. Continuous because Claude maintains state across sessions. Compounding because each session makes the system smarter—learnings accumulate like compound interest.
Design Principles
An agent is five things: Prompt + Tools + Context + Memory + Model.
| Component |
What We Optimize |
| Prompt |
Skills inject relevant context; hooks add system reminders |
| Tools |
TLDR reduces tokens; agents parallelize work |
| Context |
Not just what Claude knows, but how it's provided |
| Memory |
Daemon extracts learnings; recall surfaces them |
| Model |
Becomes swappable when the other four are solid |
Anti-Complexity
We resist plugin sprawl. Every MCP, subscription, and tool you add promises improvement but risks breaking context, tools, or prompts through clashes.
Our approach:
- Time, not money — No required paid services. Perplexity and NIA are optional, high-value-per-token.
- Learn, don't accumulate — A system that learns handles edge cases better than one that collects plugins.
- Shift-left validation — Hooks run pyright/ruff after edits, catching errors before tests.
The failure modes of complex systems are structurally invisible until they happen. A learning, context-efficient system doesn't prevent all failures—but it recovers and improves.
How to Talk to Claude
You don't need to memorize slash commands. Just describe what you want naturally.
The Skill Activation System
When you send a message, a hook injects context that tells Claude which skills and agents are relevant. Claude infers from a rule-based system and decides which tools to use.
> "Fix the login bug in auth.py"
🎯 SKILL ACTIVATION CHECK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ CRITICAL SKILLS (REQUIRED):
→ create_handoff
📚 RECOMMENDED SKILLS:
→ fix
→ debug
🤖 RECOMMENDED AGENTS (token-efficient):
→ debug-agent
→ scout
ACTION: Use Skill tool BEFORE responding
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Priority Levels
| Level |
Meaning |
| ⚠️ CRITICAL |
Must use (e.g., handoffs before ending session) |
| 📚 RECOMMENDED |
Should use (e.g., workflow skills) |
| 💡 SUGGESTED |
Consider using (e.g., optimization tools) |
| 📌 OPTIONAL |
Nice to have (e.g., documentation helpers) |
Natural Language Examples
| What You Say |
What Activates |
| "Fix the broken login" |
/fix workflow → debug-agent, scout |
| "Build a user dashboard" |
/build workflow → plan-agent, kraken |
| "I want to understand this codebase" |
/explore + scout agent |
| "What could go wrong with this plan?" |
/premortem |
| "Help me figure out what I need" |
/discovery-interview |
| "Done for today" |
create_handoff (critical) |
| "Resume where we left off" |
resume_handoff |
| "Research auth patterns" |
oracle agent + perplexity |
| "Find all usages of this API" |
scout agent + ast-grep |
Why This Approach?
| Benefit |
How |
| More Discoverable |
Don't need to know commands exist |
| Context-Aware |
System knows when you're 90% through context |
| Reduces Cognitive Load |
Describe intent naturally, get curated suggestions |
| Power User Friendly |
Still supports /fix, /build, etc. directly |
Skill vs Workflow vs Agent
| Type |
Purpose |
Example |
| Skill |
Single-purpose tool |
commit, tldr-code, qlty-check |
| Workflow |
Multi-step process |
/fix (sleuth → premortem → kraken → commit) |
| Agent |
Specialized sub-session |
scout (exploration), oracle (research) |
See detailed skill activation docs →
Quick Start
Prerequisites
- Python 3.11+
- uv package manager
- Docker (for PostgreSQL)
- Claude Code CLI
Installation
# Clone
git clone https://github.com/parcadei/Continuous-Claude-v3.git
cd Continuous-Claude-v3/opc
# Run setup wizard (12 steps)
uv run python -m scripts.setup.wizard
Note: The pyproject.toml is in opc/. Always run uv commands from the opc/ directory.
What the Wizard Does
| Step |
What It Does |
| 1 |
Backup existing .claude/ config (if present) |
| 2 |
Check prerequisites (Docker, Python, uv) |
| 3-5 |
Database + API key configuration |
| 6-7 |
Start Docker stack, run migrations |
| 8 |
Install Claude Code integration (32 agents, 109 skills, 30 hooks) |
| 9 |
Math features (SymPy, Z3, Pint - optional) |
| 10 |
TLDR code analysis tool |
| 11-12 |
Diagnostics tools + Loogle (optional) |
To Uninstall:
cd Continuous-Claude-v3/opc
uv run python -m scripts.setup.wizard --uninstall
What it does
- Archives your current setup → Moves ~/.claude to ~/.claude-v3.archived.
- Restores your backup → Finds the most recent ~/.claude.backup.* (created during install) and restores it
- Preserves user data → Copies these back from the archive:
- history.jsonl (your command history)
- mcp_config.json (MCP servers)
- .env (API keys)
- projects.json (project configs)
- file-history/ directory
- projects/ directory
- Removes CC-v3 additions → Everything else (hooks, skills, agents, rules)
Safety Features
- Your current setup is archived with timestamp - nothing gets deleted
- The wizard asks for confirmation before proceeding
- It restores from the backup that was made during installation
- All your Claude Code settings stay intact
Remote Database Setup
By default, CC-v3 runs PostgreSQL locally via Docker. For remote database setups:
1. Database Preparation
# Connect to your remote PostgreSQL instance
psql -h hostname -U user -d continuous_claude
# Enable pgvector extension (requires superuser or rds_superuser)
CREATE EXTENSION IF NOT EXISTS vector;
# Apply the schema (from your local clone)
psql -h hostname -U user -d continuous_claude -f docker/init-schema.sql
Managed PostgreSQL tips:
- AWS RDS: Add
vector to shared_preload_libraries in DB Parameter Group
- Supabase: Enable via Database Extensions page
- Azure Database: Use Extensions pane to enable pgvector
2. Connection Configuration
Set CONTINUOUS_CLAUDE_DB_URL in ~/.claude/settings.json:
{
"env": {
"CONTINUOUS_CLAUDE_DB_URL": "postgresql://user:password@hostname:5432/continuous_claude"
}
}
Or export before running Claude:
export CONTINUOUS_CLAUDE_DB_URL="postgresql://user:password@hostname:5432/continuous_claude"
claude
See .env.example for all available environment variables.
First Session
# Start Claude Code
claude
# Try a workflow
> /workflow
First Session Commands
| Command |
What it does |
/workflow |
Goal-based routing (Research/Plan/Build/Fix) |
/fix bug <description> |
Investigate and fix a bug |
/build greenfield <feature> |
Build a new feature from scratch |
/explore |
Understand the codebase |
/premortem |
Risk analysis before implementation |
Architecture
┌─────────────────────────────────────────────────────────────────────┐
│ CONTINUOUS CLAUDE │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Skills │ │ Agents │ │ Hooks │ │
│ │ (109) │───▶│ (32) │◀───│ (30) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ TLDR Code Analysis │ │
│ │ L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing │ │
│ │ (95% token savings) │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Memory │ │ Continuity │ │ Coordination│ │
│ │ System │ │ Ledgers │ │ Layer │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
Data Flow: Session Lifecycle
SessionStart Working SessionEnd
│ │ │
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Load │ │ Track │ │ Save │
│ context │─────────────────▶│ changes │──────────────────▶│ state │
└─────────┘ └─────────┘ └─────────┘
│ │ │
├── Continuity ledger ├── File claims ├── Handoff
├── Memory recall ├── TLDR indexing ├── Learnings
└── Symbol index └── Blackboard └── Outcome
│
▼
┌─────────┐
│ /clear │
│ Fresh │
│ context │
└─────────┘
The Continuity Loop (Detailed)
┌─────────────────────────────────────────────────────────────────────────────┐
│ THE CONTINUITY LOOP │
└─────────────────────────────────────────────────────────────────────────────┘
1. SESSION START 2. WORKING
┌────────────────────┐ ┌────────────────────┐
│ │ │ │
│ Ledger loaded ────┼──▶ Context │ PostToolUse ──────┼──▶ Index handoffs
│ Handoff loaded │ │ UserPrompt ───────┼──▶ Skill hints
│ Memory recalled │ │ Edit tracking ────┼──▶ Dirty flag++
│ TLDR cache warmed │ │ SubagentStop ─────┼──▶ Agent reports
│ │ │ │
└────────────────────┘ └────────────────────┘
│ │
│ ▼
│ ┌────────────────────┐
│ │ 3. PRE-COMPACT │
│ │ │
│ │ Auto-handoff ─────┼──▶ thoughts/shared/
│ │ (YAML format) │ handoffs/*.yaml
│ │ Dirty > 20? ──────┼──▶ TLDR re-index
│ │ │
│ └────────────────────┘
│ │
│ ▼
│ ┌────────────────────┐
│ │ 4. SESSION END │
│ │ │
│ │ Stale heartbeat ──┼──▶ Daemon wakes
│ │ Daemon spawns ────┼──▶ Headless Claude
│ │ Thinking blocks ──┼──▶ archival_memory
│ │ │
│ └────────────────────┘
│ │
│ │
└──────────────◀────── /clear ◀──────┘
Fresh context + state preserved
Workflow Chains
┌─────────────────────────────────────────────────────────────────────────────┐
│ META-SKILL WORKFLOWS │
└─────────────────────────────────────────────────────────────────────────────┘
/fix bug /build greenfield
───────── ─────────────────
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ sleuth │─▶│ premortem│ │discovery │─▶│plan-agent│
│(diagnose)│ │ (risk) │ │(clarify) │ │ (design) │
└──────────┘ └────┬─────┘ └──────────┘ └────┬─────┘
│ │
▼ ▼
┌──────────┐ ┌──────────┐
│ kraken │ │ validate │
│ (fix) │ │ (check) │
└────┬─────┘ └────┬─────┘
│ │
▼ ▼
┌──────────┐ ┌──────────┐
│ arbiter │ │ kraken │
│ (test) │ │(implement│
└────┬─────┘ └────┬─────┘
│ │
▼ ▼
┌──────────┐ ┌─�
Continuous Claude 是叠加在 Claude Code 之上的插件/环境，添加了持久记忆、节省上下文的交接和多代理编排，让 Claude 跨会话持续积累经验，而不是在上下文压缩时丢失信息。