JSPM

• AST Code Indexing — Tree-sitter parsing for 21 languages (13 with full symbol extraction + 8 grammar-only); symbol-aware BM25 tokenization boosts function/class names in search results
• Web Search — Real-time search via Perplexity Sonar through OpenRouter (quick $1/MTok, quality $3-15/MTok, deep research); search history tracking with cost auditing
• PRD Pipeline — Generate PRDs from feature descriptions, parse into executable tasks, run with Claude Code agent, export workflow to Obsidian (Mermaid Gantt + dependency DAG)
• Team Mode — Parallel task execution using git worktrees; each worker gets an isolated checkout, results merge via cherry-pick
• Quality Gates — Auto-detected (TypeScript, Go, Python, Rust) or custom; run after each task to verify code quality
• Graph Enrichment — LLM-classified relations (implements, leads_to, contradicts...), contextual proximity, Label Propagation communities, degree centrality with recall boost
• Dead-End Tracking — Record failed approaches; auto-boosted in recall to prevent retrying
• AGENTS.md Auto-Export — Auto-generate editor instructions from decisions, patterns, dead-ends
• Learning Delta — Track knowledge growth per session (memories added, types, quality)
• Confidence Retention — Time-decay scoring with auto-cleanup of low-value memories
• Safe Consolidation — Soft-delete with undo support; no data loss on merge
• Skill Discovery — Auto-suggest relevant skills based on user prompt (opt-in, disabled by default)
• Skyll Integration — Access community skills from Skyll registry (requires skills.enabled = true)
• Soul Document — Define AI personality and values
• Auto-Hooks — Context injection at session start/end
• Idle Reflections — AI generates insights during idle time
• Session Context — Auto-generated briefings for next session
• Sensitive Filter — Detect and redact PII, API keys, secrets
• Quality Scoring — Local ONNX classification to filter noise
• Token Savings — Track RAG efficiency vs full files
• Temporal Awareness — Time decay, validity periods, point-in-time queries
• Unified Daemon — Single background process for watch, analyze, idle tracking
• Watch Mode — Auto-reindex on file changes via @parcel/watcher
• Fast Analyze — --fast mode with fewer agents and smaller context for quick onboarding
• Incremental Analyze — Git-based change detection, skip unchanged agents
• Local LLM — Ollama, LM Studio, llama.cpp support
• Sleep Agent — Offload heavy operations to local LLM
• Checkpoints — Backup and restore full succ state
• AI-Readiness Score — Measure project readiness for AI collaboration
• Multiple LLM Backends — Local (Ollama), OpenRouter, or Claude CLI
• Storage Backends — SQLite (default), PostgreSQL + pgvector, Qdrant
• Data Migration — Export/import JSON, migrate between backends

Local (default):

{
  "llm": { "embeddings": { "mode": "local" } }
}

Ollama (unified namespace):

{
  "llm": {
    "embeddings": {
      "mode": "api",
      "model": "nomic-embed-text",
      "api_url": "http://localhost:11434/v1/embeddings"
    }
  }
}

OpenRouter:

{
  "embedding_mode": "openrouter",
  "openrouter_api_key": "sk-or-..."
}

MRL dimension override (Matryoshka models):

{
  "llm": {
    "embeddings": {
      "mode": "api",
      "model": "nomic-embed-text-v1.5",
      "api_url": "http://localhost:11434/v1/embeddings",
      "dimensions": 256
    }
  }
}

succ uses native ONNX Runtime for embedding inference with automatic GPU detection:

GPU is enabled by default. No manual configuration needed — the best available backend is auto-detected.

{
  "gpu_enabled": true,
  "gpu_device": "directml"
}

Set gpu_device to override auto-detection: cuda, directml, coreml, or cpu.

Automatically run the succ-diff-reviewer agent before every git commit to catch security issues, bugs, and regressions:

{
  "preCommitReview": true
}

When enabled, Claude will run a diff review before each commit. Critical findings block the commit; high findings trigger a warning.

Disabled by default. Set via succ config_set preCommitReview true.

Offload heavy operations to local LLM:

{
  "idle_reflection": {
    "sleep_agent": {
      "enabled": true,
      "mode": "local",
      "model": "qwen2.5-coder:14b",
      "api_url": "http://localhost:11434/v1"
    }
  }
}

succ supports multiple storage backends for different deployment scenarios:

Example: PostgreSQL + pgvector

{
  "storage": {
    "backend": "postgresql",
    "postgresql": {
      "connection_string": "postgresql://user:pass@localhost:5432/succ"
    }
  }
}

Example: PostgreSQL + Qdrant

{
  "storage": {
    "backend": "postgresql",
    "vector": "qdrant",
    "postgresql": { "connection_string": "postgresql://..." },
    "qdrant": { "url": "http://localhost:6333" }
  }
}

See Storage Configuration for all options.

succ supports multiple LLM backends for operations like analyze, idle reflection, and skill suggestions:

{
  "llm": {
    "type": "local",
    "model": "qwen2.5:7b",
    "local": {
      "endpoint": "http://localhost:11434/v1/chat/completions"
    },
    "openrouter": {
      "model": "anthropic/claude-3-haiku"
    }
  }
}

Transport auto-selects based on type: claude uses process (or ws for persistent WebSocket), local/openrouter use http.

WebSocket transport (transport: "ws") keeps a persistent connection to Claude CLI, avoiding process spawn overhead on repeated calls:

{
  "llm": {
    "type": "claude",
    "model": "sonnet",
    "transport": "ws"
  }
}

Per-backend model overrides for the fallback chain:

{
  "llm": {
    "type": "claude",
    "model": "sonnet",
    "transport": "ws",
    "local": { "endpoint": "http://localhost:11434/v1/chat/completions", "model": "qwen2.5:7b" },
    "openrouter": { "model": "anthropic/claude-3-haiku" }
  }
}

Claude backend usage

The claude backend integrates with an existing, locally running Claude Code session and is intended only for in-session developer assistance by the same user, including tasks such as file analysis, documentation, indexing, and session summarization.

It is not supported for unattended background processing, cloud deployments, or multi-user scenarios. For automated, long-running, or cloud workloads, use the local or openrouter backends instead.