Comparison: Continuous Claude (v3) and Claude-Mem (v9)

[artile]

Technical Comparison: Continuous Claude v3 vs Claude-Mem v9

Overview

This document compares two distinct approaches to solving Claude Code context degradation:

Aspect	Continuous Claude v3	Claude-Mem
Type	Agentic IDE (Heavy)	Memory Plugin (Light)
Philosophy	Compound > Compact (Structure & Rigor)	Capture > Compress > Inject (Flow & Continuity)
State Storage	PostgreSQL + pgvector (Docker)	SQLite + Chroma (Local)
Code Analysis	TLDR Tool (5-layer AST/CFG/DFG)	Standard text/grep + Vector search
Agents	32 Specialized Agents	Single optimized worker + Search Skill
Memory Capture	Hybrid: Manual + Auto-Daemon	Fully Automatic
Search Engine	Hybrid RRF (Text + Vector) + Artifact Index	Chroma (Vector) + SQLite FTS5
User Interface	CLI Status Line	Web Dashboard (Port 37777)
Runtime	Python (uv), Docker, Node.js	Bun / Node.js
License	MIT	AGPL-3.0

---

Core Philosophy

Continuous Claude v3: Compound > Compact

Philosophy: Context is finite and precious. Don't just compress text; analyze code structure (AST) to save tokens. Use specialized agents to enforce rigorous workflows like TDD and formal verification.

Claude-Mem: Capture > Compress > Inject

Philosophy: Memory should be automatic and invisible. Users shouldn't manage state. Use "Progressive Disclosure" (Index → Timeline → Details) to present memory only when relevant, preserving flow without imposing structure.

---

Workflow Patterns

Continuous Claude: Goal-Router → Agent Chain

User types: /fix bug "login error"

System routes:
Sleuth (investigate) → Premortem (risk check) → Kraken (TDD implement) → Arbiter (verify)

Focus: Correctness, safety, and structured engineering.

Claude-Mem: Search-Driven Context

User types: "Fix the login error"

System triggers:
mem-search → recalls how login was built → injects context → Claude acts

Focus: Speed, continuity, and "remembering what we did last time."

---

Continuous Claude v3 Exclusive Features

TLDR Code Analysis

• Custom tool analyzing code at 5 layers: AST, Call Graph, Control Flow, Data Flow, Slicing
• Reduces token usage by ~95% compared to reading raw files

Formal Verification (/prove)

• Integration with Lean 4 and Godel-Prover
• Generate machine-verified mathematical proofs

Memory Daemon

• Background process extracting "learning" from Claude's thinking blocks
• Captures reasoning history, not just output

Skill Activation System

• Natural language intent detection
• Suggests critical/recommended skills (e.g., "⚠️ Critical: create_handoff")

Multi-Agent Patterns

• Orchestrator agents ("Maestro") spawn sub-agents
• Patterns: "Jury" (multiple reviews), "Debate"

Strict TDD Enforcement

• Kraken agent refuses to write code until a failing test exists

---

Claude-Mem Exclusive Features

Web Viewer UI

• Beautiful React interface (localhost:37777)
• Browse memory, view timelines, debug session history visually

Progressive Disclosure

• 3-layer retrieval: Search Index → Time-bound Timeline → Full Observations
• Optimizes token usage by filtering relevance before fetching details

Endless Mode (Beta)

• Biomimetic memory architecture
• Sessions run indefinitely without context fragmentation

Zero-Config Automation

• No Docker, no setup wizard, no manual database management
• Works immediately upon installation

Privacy Tags

• Support for <private> tags
• Explicitly exclude sensitive data from long-term memory

---

Trade-offs

Continuous Claude Strengths

Strength	Description
Engineering Rigor	Best for large, complex projects where architecture and TDD matter more than speed
Token Efficiency	TLDR tool vastly superior for reading large codebases without blowing context
Verification	Unique capability to mathematically prove code correctness
License	MIT (Permissive)

Claude-Mem Strengths

Strength	Description
User Experience	"It just works" - Zero friction, beautiful UI, no Docker overhead
Flow	Best for solo developers or fast prototyping where agent chains feel "heavy"
Visual Memory	Ability to "see" memory stream in browser builds confidence
Privacy	AGPL-3.0 (Copyleft)

---

Recommendations

Choose Continuous Claude v3 if:

• You want an AI Co-founder
• Building complex systems
• Care deeply about TDD/Architecture
• Comfortable with Docker/Python
• Want AI to "plan" and "execute" autonomously

Choose Claude-Mem if:

• You want a Second Brain
• Want Claude to simply "remember" everything without changing workflow
• Prefer lightweight setup
• Want a visual dashboard of project history

[parcadei]

Hi! Continuous Claude v3 issue bot here. Thanks for the detailed comparison - always good to see analysis across tools.

A few factual corrections:

Memory Capture isn't just "Manual + Auto-Daemon"

We also have automatic memory injection via hooks. The memory-awareness hook triggers on every user prompt and auto-injects relevant learnings into context - similar to what you describe Claude-Mem doing. So the "Workflow Patterns" comparison is a bit off:

User: "Fix the login error"

Our system:
1. memory-awareness hook → auto-recalls relevant learnings (like Claude-Mem)
2. PLUS /fix workflow → Sleuth → Kraken → Arbiter (structured agents)

We're actually a superset - we do automatic recall AND structured agent workflows.

Plus: Explicit Memory

Users can also say "remember how we built the login system" and it gets stored. Next time a related task comes up, it's automatically recalled via hooks. Best of both worlds - automatic capture from thinking blocks + explicit user-directed memory.

Minor corrections:

• TLDR has 5 layers (AST, Call Graph, CFG, DFG, PDG), not 4
• "Debate" pattern doesn't exist by that name - we have "generator_critic" for adversarial review
• Kraken's TDD is guidance, not a hard block

On the comparison itself:

Fair enough to compare, but this is more apples vs oranges than apples to apples - they solve different problems. Or just have a fruit salad and use both.

— v3 bot 🤖

[alexx-ftw]

I would like an in-depth comparison to https://github.com/steveyegge/gastown , if at all possible

[artile]

Hi bot. Many thanks for your reply. It's very valuable. Also, in this regard, I believe this is not an issue, it's more like a discussion and is it possible for author to activate discussions? Because when I saw first comparison it was very valuable for me, this is why I have created this second one and uh I'm about to send another one with Gus down and issue should be closed, but discussions would be nice to have in more long term.

[artile]

Multi-Agent Orchestration Systems: Gas Town vs Continuous Claude v3

Date: 2026-01-11
Compared Projects:

• Gas Town (gastown) - github.com/steveyegge/gastown
• Continuous Claude v3 - parcadei/Continuous-Claude-v3

---

Executive Summary

Both systems are sophisticated multi-agent orchestration platforms for Claude Code, but they take fundamentally different architectural approaches to solving the same core problem: maintaining context across AI agent sessions and coordinating multiple specialized agents.

Aspect	Gas Town	Continuous Claude v3
Language	Go 1.24.2	Python 3.12+
Core Innovation	Git worktrees + Beads for persistence	TLDR 5-layer analysis + PostgreSQL memory
Agent Count	~8 specialized agent types	32 specialized agents
State Management	Git-backed JSONL "Beads"	PostgreSQL + pgvector
Context Efficiency	Git-based diffing	95% token reduction via TLDR
Primary Mechanism	GUPP (Hooks as propulsion)	Hooks + Memory + Skills

---

Architecture Comparison

Gas Town: Git-Native Architecture

Philosophy: "Zero Framework Cognition" - State derived from filesystem, not memory

~/gt/                           # Town root
├── .beads/                     # Town-level coordination (hq-*)
├── mayor/                      # Mayor config
└── <rig>/                      # Project container
    ├── mayor/rig/              # Canonical clone (beads here)
    ├── refinery/rig/           # Worktree
    ├── witness/                # Monitor (no clone)
    ├── crew/<name>/            # Human workspaces (full clones)
    └── polecats/<name>/        # Worker worktrees (ephemeral)

Key Principles:

• GUPP (Gas Town Universal Propulsion Principle): "If there is work on your Hook, YOU MUST RUN IT"
• MEOW (Molecular Expression of Work): Breaking goals into detailed agent instructions
• NDI (Nondeterministic Idempotence): Orchestrating unreliable processes for useful outcomes

Continuous Claude v3: Database-Native Architecture

Philosophy: "Compound, Don't Compact" - System improves through learning

Cosm/                          # Technical layer
├── .claude/                   # Skills (109), Agents (32), Hooks (30)
├── opc/                       # Core Python package
│   ├── scripts/               # Setup, memory, MCP, TLDR
│   └── docker/                # PostgreSQL stack
└── thoughts/                  # State persistence
    ├── ledgers/               # Continuity tracking
    └── shared/handoffs/       # Session handoffs

---

Technology Stack Comparison

Core Technologies

Component	Gas Town	Continuous Claude v3
Language	Go 1.24.2	Python 3.12+
CLI Framework	cobra	Custom (via Claude Code)
TUI Framework	bubbletea	None (CLI-first)
Data Store	Beads (git-backed JSONL)	PostgreSQL + pgvector
Session Mgmt	tmux 3.0+	PostgreSQL sessions table
Browser Automation	rod	Not specified
Embeddings	None	BGE-large-en-v1.5 (1024-dim)
Code Analysis	Git-based	Tree-sitter + TLDR (5-layer)

Agent Taxonomy Comparison

Gas Town Agents (8 types)

Town-Level (Cross-Rig):

• Mayor - Global coordinator, cross-rig communication
• Deacon - Daemon beacon, heartbeats, monitoring plugins
• Dogs - Long-running workers for batch work (fixed pool of 5)

Rig-Level (Per-Project):

• Witness - Monitors polecat health, handles nudging/cleanup
• Refinery - Processes merge queue, runs verification
• Polecats - Ephemeral workers for specific issues

Continuous Claude v3 Agents (32 types)

Orchestrators (2): maestro, kraken
Planners (4): architect, phoenix, plan-agent, validate-agent
Explorers (4): scout, oracle, pathfinder, research-codebase
Implementers (3): kraken, spark, agentica-agent
Debuggers (3): sleuth, debug-agent, profiler
Validators (2): arbiter, atlas
Reviewers (6): critic, judge, surveyor, liaison, plan-reviewer, review-agent
Specialized (8): aegis, herald, scribe, chronicler, session-analyst, braintrust-analyst, memory-extractor, onboard

---

State Persistence Mechanisms

Gas Town: Beads System

Concept: Git-backed atomic work units stored in JSONL format

Type	Purpose
Bead	Atomic work unit
Formula	TOML-based workflow template
Molecule	Durable chained Bead workflows
Wisp	Ephemeral Beads (destroyed after runs)
Hook	Special pinned Bead (agent's work queue)
Convoy	Work-order wrapping related Beads

Two-Level Architecture:

• Town beads (~/gt/.beads/) - Cross-rig coordination
• Rig beads (<rig>/mayor/rig/.beads/) - Implementation work

Continuous Claude v3: Memory + Handoffs

Concept: PostgreSQL-backed semantic memory with embeddings

Table	Purpose
sessions	Cross-terminal awareness
file_claims	Cross-terminal file locking
archival_memory	Long-term learnings with BGE embeddings
handoffs	Session handoffs with embeddings

Continuity Components:

• Continuity Ledger - Within-session state (thoughts/ledgers/CONTINUITY_*.md)
• Handoffs - Between-session transfer (thoughts/shared/handoffs/*.yaml)
• Auto-save - PreCompact hook creates handoffs before compaction

---

Context Efficiency Strategies

Gas Town: Git Worktrees

Mechanism: Uses git worktrees as the propulsion system

• Each agent gets its own worktree
• Changes tracked via git diff
• State persisted in Beads (JSONL in git)
• Version-controlled by design

Benefits:

• Natural version control
• Crash recovery via git
• Minimal overhead (git-native)

Continuous Claude v3: TLDR Code Analysis

Mechanism: 5-layer static analysis achieving 95% token reduction

Layer	Name	Output	Tokens
L1	AST	Functions, classes, signatures	~500
L2	Call Graph	Cross-file dependencies	+440
L3	CFG	Control flow, complexity	+110
L4	DFG	Data flow, variable tracking	+130
L5	PDG	Program slicing, impact	+150

Total: ~1,200 tokens vs 23,000 raw = 95% savings

Features:

• Semantic index with natural language queries
• Auto-rebuild on file changes (dirty flag)
• .tldrignore for selective indexing

---

Communication Patterns

Gas Town

Mechanism	Purpose
Mail System	Async message passing via beads
Nudging	Real-time tmux-based messaging
Handoff	Agent session refresh via /handoff
Seance	Communicating with previous sessions

Continuous Claude v3

Mechanism	Purpose
Skills (109)	Modular capabilities with NL triggers
Meta-Skills	Workflow orchestration (/build, /fix, /tdd)
Hooks (30)	Lifecycle interceptors
Dynamic Recall	Semantic memory retrieval

---

Command Structure

Gas Town CLI

# Workspace Management
gt install <path>           # Initialize workspace
gt rig add <name> <repo>    # Add project
gt crew add <name> --rig <rig>  # Create crew workspace

# Agent Operations
gt agents                   # List active agents
gt sling <issue> <rig>      # Assign work to agent
gt mayor attach             # Start Mayor session
gt prime                    # Prime session with context

# Convoy (Work Tracking)
gt convoy create <name> [issues...]
gt convoy list
gt convoy show [id]

# Mail System
gt mail check
gt mail send <agent>
gt mail mark-read <id>

# Maintenance
gt doctor                   # Health check
gt down --polecats          # Shut down polecats
gt hooks repair             # Fix broken hooks

Continuous Claude v3 CLI

# Meta-Skills (Workflow Orchestrators)
/workflow                    # Goal-based routing
/build <type>                # Feature development
/fix <type>                  # Bug resolution
/tdd                         # Test-driven development
/refactor                    # Safe code transformation
/review                      # Comprehensive code review
/explore <depth>             # Codebase exploration
/premortem <plan>            # Risk analysis

# Memory Operations
cd opc && uv run python scripts/core/recall_learnings.py --query "<topic>"
cd opc && uv run python scripts/core/store_learning.py [...]

# TLDR Analysis
tldr tree [path]             # File tree
tldr search <pattern>        # Search files
tldr context <entry>         # LLM-ready context
tldr impact <func>           # Reverse call graph
tldr diagnostics <path>      # Type check + lint

# Setup & Maintenance
cd opc && uv run python -m scripts.setup.wizard    # Initial setup
cd opc && uv run python -m scripts.setup.update     # Update system

---

Development Workflow

Gas Town

Adding Commands:

1. Create file in internal/cmd/<command>.go
2. Follow cobra command pattern
3. Add to appropriate parent command

Testing:

make build
make test
go test ./internal/polecat/...

Git Workflow:

• Main branch: main
• Conventional commits used
• PR policy in crew.md.tmpl

Continuous Claude v3

Adding Skills:

1. Create .claude/skills/my-skill/SKILL.md
2. Add trigger to .claude/skills/skill-rules.json
3. Test with /my-skill or natural language

Creating Agents:

1. Create .claude/agents/my-agent.md
2. Define frontmatter (name, description, model, tools)
3. Write prompt following existing patterns

Developing Hooks:

1. Create shell or TypeScript hook in .claude/hooks/
2. Add to .claude/settings.json
3. Test with /debug-hooks

---

Build & Test Comparison

Gas Town

# Build
make build              # Builds gt binary
make install            # Copies to ~/.local/bin/

# Test
make test               # Runs test suite
go test ./internal/cmd/... -run Integration

Continuous Claude v3

# Setup
cd opc && uv sync                                    # Python deps
cd ../.claude/hooks && npm install && npm run build  # Hook deps
cd ../opc && docker-compose up -d                    # Database

# Test
cd opc && pytest                                     # Python tests
cd opc/packages/tldr-code && pytest tests/           # TLDR tests
cd ../.claude/hooks && npm test                      # Hook tests

# Quality
ruff check .          # Linting
mypy .                # Type checking

---

Key Differentiators

Gas Town Advantages

1. Git-Native Persistence

   • Version control built into core architecture
   • Natural crash recovery
   • No external database dependency

2. TUI Experience

   • bubbletea provides rich terminal UI
   • Visual monitoring of agent states

3. Browser Automation

   • Rod integration for web-based tasks

4. Mature Agent Lifecycle

   • Self-cleaning polecats
   • Sophisticated monitoring via Witness

5. Simpler Deployment

   • Single binary (gt)
   • Beads as only external dependency

Continuous Claude v3 Advantages

1. Semantic Memory

   • PostgreSQL + pgvector for intelligent recall
   • BGE embeddings for similarity search
   • Automatic learning extraction

2. Massive Capability Library

   • 109 skills vs minimal GT equivalents
   • Meta-skill orchestration patterns
   • Rich workflow support (/build, /fix, /tdd)

3. Token Efficiency

   • 95% reduction via TLDR
   • 5-layer static analysis
   • .tldrignore for control

4. Advanced Math & Verification

   • SymPy symbolic computation
   • Z3 constraint solving
   • Lean4 formal proofs support

5. Cross-Terminal Coordination

   • Session awareness via database
   • File claim locking
   • Real-time peer detection

---

Use Case Recommendations

Choose Gas Town If:

• You prefer Go over Python
• You want git-native state management
• You need browser automation capabilities
• You prefer TUI interfaces over CLI
• You want minimal external dependencies
• You're building team-scale coordination
• You value crash resilience via git

Choose Continuous Claude v3 If:

• You prefer Python ecosystem
• You want semantic memory with embeddings
• You need extensive pre-built skills (109)
• You want token efficiency (95% savings)
• You need math/verification capabilities
• You want workflow orchestration (/build, /fix)
• You're building personal productivity system
• You value cross-terminal coordination

---

Architecture Diagrams

Gas Town: Git-Propelled Multi-Agent System

┌─────────────────────────────────────────────────────────────────┐
│                          Gas Town                               │
│                         ~/gt/                                   │
├─────────────────────────────────────────────────────────────────┤
│  Town Level                                                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │   Mayor     │  │   Deacon    │  │   Dogs      │            │
│  │ (Coordinator)│  │ (Beacon)    │  │ (Workers)   │            │
│  └─────────────┘  └─────────────┘  └─────────────┘            │
│         │                 │                                  │
│         └─────────────────┴──────────┐                       │
│                                     ▼                       │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Town Beads (hq-*)                      │    │
│  │              ~/gt/.beads/                           │    │
│  └─────────────────────────────────────────────────────┘    │
├─────────────────────────────────────────────────────────────────┤
│  Rig Level (per project)                                       │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  ┌─────────┐  ┌──────────┐  ┌─────────┐            │    │
│  │  │ Witness │  │ Refinery │  │Polecats │            │    │
│  │  │(Monitor)│  │ (Merge)   │  │(Workers)│            │    │
│  │  └─────────┘  └──────────┘  └─────────┘            │    │
│  │                                                  │    │
│  │  ┌─────────────────────────────────────────┐    │    │
│  │  │         Rig Beads (project-*)          │    │    │
│  │  │         <rig>/mayor/rig/.beads/        │    │    │
│  │  └─────────────────────────────────────────┘    │    │
│  │                                                  │    │
│  │  Git Worktrees:                                  │    │
│  │  ├─ mayor/rig/     (canonical)                   │    │
│  │  ├─ refinery/rig/  (worktree)                    │    │
│  │  ├─ crew/name/     (full clones)                 │    │
│  │  └─ polecats/name/ (worktrees)                   │    │
│  └─────────────────────────────────────────────────────┘    │
├─────────────────────────────────────────────────────────────────┤
│  GUPP: "If there is work on your Hook, YOU MUST RUN IT"        │
│  MEOW: Molecular Expression of Work                             │
│  NDI: Nondeterministic Idempotence                              │
└─────────────────────────────────────────────────────────────────┘

Continuous Claude v3: Memory-Powered Learning System

┌─────────────────────────────────────────────────────────────────┐
│                   Continuous Claude v3                          │
├─────────────────────────────────────────────────────────────────┤
│  Skills Layer (109 modular capabilities)                        │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ Meta-Skills: /workflow, /build, /fix, /tdd, /review │       │
│  │ Specialized: pre-mortem, discovery, handoffs, math  │       │
│  └─────────────────────────────────────────────────────┘       │
│                              │                                  │
│                              ▼                                  │
│  Hooks Layer (30 lifecycle interceptors)                        │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ SessionStart │ PreToolUse │ PostToolUse │ SessionEnd│       │
│  │ tldr-router │ smart-search │ memory-awareness │     │       │
│  └─────────────────────────────────────────────────────┘       │
│                              │                                  │
│                              ▼                                  │
│  Agents Layer (32 specialized workers)                          │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ Orchestrators │ Planners │ Explorers │ Implementers │       │
│  │ Debuggers │ Validators │ Reviewers │ Specialized   │       │
│  └─────────────────────────────────────────────────────┘       │
│                              │                                  │
│                              ▼                                  │
│  Memory Layer (PostgreSQL + pgvector)                          │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ sessions │ file_claims │ archival_memory │ handoffs │       │
│  │                  BGE embeddings (1024-dim)           │       │
│  └─────────────────────────────────────────────────────┘       │
│                              │                                  │
│                              ▼                                  │
│  Analysis Layer (TLDR - 95% token savings)                     │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ L1:AST │ L2:CallGraph │ L3:CFG │ L4:DFG │ L5:PDG │       │
│  └─────────────────────────────────────────────────────┘       │
├─────────────────────────────────────────────────────────────────┤
│  OS/ Layer (PARA Method - User Workspace)                       │
│  ┌─────────────────────────────────────────────────────┐       │
│  │ Projects/ │ Areas/ │ Resources/ │ Archives/          │       │
│  └─────────────────────────────────────────────────────┘       │
├─────────────────────────────────────────────────────────────────┤
│  Agent = Prompt + Tools + Context + Memory + Model              │
│  "Compound, Don't Compact"                                      │
└─────────────────────────────────────────────────────────────────┘

---

Convergence Opportunities

Both systems could benefit from cross-pollination:

Gas Town Could Borrow:

1. Semantic Memory - Add pgvector for intelligent recall
2. TLDR Analysis - 95% token savings would benefit GT
3. Meta-Skills - Rich workflow orchestration patterns
4. Hook System - Lifecycle interceptors for automation

Continuous Claude v3 Could Borrow:

1. Git Worktrees - Natural version control for state
2. Self-Cleaning Agents - Polecat auto-termination pattern
3. Mail System - Async agent messaging
4. TUI Monitoring - bubbletea for visual agent tracking

---

Conclusion

Both Gas Town and Continuous Claude v3 represent sophisticated approaches to multi-agent orchestration, but they optimize for different scenarios:

• Gas Town excels at team-scale coordination with git-native resilience
• Continuous Claude v3 excels at personal productivity with semantic intelligence

The choice depends on:

• Primary language preference (Go vs Python)
• State management philosophy (git vs database)
• Scale (team coordination vs personal automation)
• Feature priorities (browser automation vs math verification)

Both systems are actively maintained (as of 2026-01-11) and represent the state of the art in AI agent orchestration.