Continuous Claude (parcadei) — Summary

Continuous Claude transforms Claude Code into a continuously-learning multi-agent development environment. Its mantra is "compound, don't compact": instead of losing context on compaction, the system extracts learnings automatically to PostgreSQL+pgvector via a background daemon, creates YAML handoff documents for cross-session continuity, and routes tasks to 32 named specialized agents (scout, oracle, kraken, aegis, maestro, etc.). With 109 skills, 30 hooks (many written in Python/TypeScript), a 5-layer TLDR code analysis system, and a natural-language skill activation engine (hook-injected suggestions via UserPromptSubmit), it is the most comprehensive single-developer AI harness in this batch. At 3,789 GitHub stars, it occupies the "maximum Claude Code power user" niche.

differs_from_seeds: Most similar to superpowers (skills-only behavioral framework) but 7x the skill count and adds PostgreSQL memory, 32 named sub-agents, a background daemon, and a multi-model memory extraction pipeline. Compared to ccmemory (the memory seed), Continuous Claude uses PostgreSQL+pgvector instead of Neo4j, extracts thinking-block reasoning rather than typed conversation nodes, and operates through a Python daemon rather than an MCP server. The YAML handoff format (400 tokens vs ~2000 for markdown) is a novel efficiency innovation not present in any seed.

Continuous Claude (parcadei) — Overview

Origin

Created by parcadei. MIT license. Python + TypeScript. Active January 2026. 3,789 stars.

Philosophy

"The mantra: Compound, don't compact. Extract learnings automatically, then start fresh with full context."

"An agent is five things: Prompt + Tools + Context + Memory + Model. We optimize each."

"We resist plugin sprawl. Every MCP, subscription, and tool you add promises improvement but risks breaking context, tools, or prompts through clashes."

The "Anti-Complexity" principle is interesting given how feature-rich Continuous Claude itself is: it resists external tool accumulation while building a rich internal tool suite.

Core Problems Solved

Memory Philosophy

"The key insight: thinking blocks contain the real reasoning — not just what Claude did, but why. The daemon extracts this automatically."

This is distinct from ccmemory's approach (which captures from conversation nodes) — Continuous Claude specifically targets Claude's extended thinking output, which contains richer reasoning than the final responses.

"Continuous" Meaning

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

Continuous Claude (parcadei) — Architecture

Distribution

Standalone repo — clone + run setup wizard. Not an npm package or plugin.

Install

git clone https://github.com/parcadei/Continuous-Claude-v3.git
cd Continuous-Claude-v3/opc
uv run python -m scripts.setup.wizard

12-step wizard: backup existing config → check prerequisites (Docker, Python, uv) → database + API keys → start Docker stack → run migrations → install Claude Code integration (32 agents, 109 skills, 30 hooks) → math features (SymPy, Z3, Pint) → TLDR tool → diagnostics + Loogle.

Directory Layout

.claude/
├── agents/          # 32 named agent .md + optional .json config files
├── hooks/           # 30+ hook scripts (Python, TypeScript, shell)
│   ├── session-start-continuity.sh
│   ├── skill-activation-prompt.sh
│   ├── memory-awareness.sh
│   ├── pre-compact-continuity.sh
│   ├── post-edit-diagnostics.sh
│   └── ...
├── skills/          # 109 skill directories
│   ├── create_handoff/SKILL.md
│   ├── resume_handoff/SKILL.md
│   ├── recall/SKILL.md
│   ├── remember/SKILL.md
│   ├── tldr-code/SKILL.md
│   └── ...
├── settings.json    # Hook registration + permissions
└── mcp_config.json  # MCP server configuration

opc/
├── docker/          # PostgreSQL + pgvector Docker Compose
├── pyproject.toml   # Python dependencies (uv)
└── scripts/
    ├── setup/wizard.py
    ├── core/recall_learnings.py
    └── core/store_learning.py

thoughts/
└── shared/
    └── handoffs/    # YAML handoff documents
        └── {session-name}/
            └── YYYY-MM-DD_HH-MM_{description}.yaml

Required Runtime

• Python 3.11+ + uv package manager
• Docker (for PostgreSQL + pgvector)
• Claude Code CLI
• Optional: Perplexity, NIA accounts for external research

Database Schema

4 tables in PostgreSQL:

• sessions — cross-terminal awareness
• file_claims — cross-terminal file locking
• archival_memory — long-term learnings with BGE embeddings
• handoffs — session handoffs with embeddings

Continuous Claude (parcadei) — Components

Agents (32)

aegis, agentica-agent, arbiter, architect, atlas, braintrust-analyst, chronicler, context-query-agent, critic, debug-agent, herald, judge, kraken, liaison, maestro, memory-extractor, onboard, oracle, pathfinder, phoenix, plan-agent, plan-reviewer, profiler, research-codebase, review-agent, scout, scribe, sentinel, + others

Key agents:

Skills (109)

Key skills:

Full list includes: agentica-, ast-grep-find, background-agent-pings, braintrust-, context management, explicit-identity, firecrawl-scrape, git-commits, github-search, graceful-degradation, loogle-search, math-, mcp-, morph-, nia-docs, observe-before-editing, perplexity-search, research-, router-first-architecture, search-, security, sub-agents, system_overview, tdd-, test, tldr-*, tour, validate-agent, wiring, workflow-router

Hooks (30+)

Memory Daemon

Background process that:

1. Detects stale session heartbeat (>5 min idle)
2. Spawns headless Claude (Sonnet)
3. Analyzes thinking blocks from session
4. Extracts learnings to archival_memory
5. Learnings available for recall next session

Continuous Claude (parcadei) — Uniqueness

differs_from_seeds

Closest to superpowers (skills-only behavioral framework for Claude Code) but 7x the skill count (109 vs 14), adds PostgreSQL+pgvector memory, 32 named sub-agents, a background memory daemon, and shift-left PostToolUse validators (pyright/ruff). Compared to ccmemory (the primary memory seed), Continuous Claude uses PostgreSQL+pgvector instead of Neo4j, extracts from Claude's thinking blocks rather than conversation nodes, and combines memory with a full 109-skill + 32-agent development harness. Unlike claude-flow (305-tool MCP server), Continuous Claude ships skills as SKILL.md files + Python scripts, not a monolithic MCP server. The YAML handoff format (400 tokens vs 2000) and thinking-block-targeted memory extraction are unique in the seed corpus.

Key Innovations

1. Thinking-block memory extraction — the daemon specifically targets Claude's extended thinking output, which contains richer reasoning than final responses
2. YAML handoffs — token-efficient session transfer (~400 tokens vs ~2000 for markdown); goal + now fields designed for statusline display
3. Shift-left validation — PostToolUse hooks run pyright + ruff after every file edit, catching errors before tests
4. Natural language skill activation — UserPromptSubmit hook injects ranked skill/agent recommendations based on message analysis; user doesn't need to know commands
5. Cross-terminal file locking — PostgreSQL file_claims table prevents concurrent editing conflicts in multi-terminal setups
6. TLDR code analysis — 5-layer system (overview/deep/router/stats) dramatically reduces tokens needed to understand a codebase

Observable Failure Modes

1. Heavy infrastructure — requires Docker + PostgreSQL; significantly higher setup complexity than any seed
2. Docker dependency — fails without Docker running
3. Daemon cost — headless Sonnet sessions triggered by daemon add API cost even when not actively developing
4. Complexity budget — 109 skills + 30 hooks + 32 agents creates risk of inter-component conflicts (the "anti-complexity" principle the author names is violated by the system itself)
5. Python 3.11 + uv requirement — specific version and tool requirements create setup friction
6. Not cross-IDE — Claude Code only; no 17-IDE adapter story like planning-with-files