Daedalus

Local-first terminal-based AI coding assistant.

Daedalus connects to local LLM servers (LM Studio, Ollama, llama.cpp, vLLM) or remote providers (OpenAI, Groq, OpenRouter, Anthropic), routes requests across models, and gives your AI agent access to your file system, terminal, git, web search, and codebase indexing.

For full guides, configuration reference, and examples, visit the documentation site: https://bgill55.github.io/daedalus/

╔═══════════════════════════════════════════════════════════════════╗
║  ██████╗  █████╗ ███████╗██████╗  █████╗ ██╗     ██╗   ██╗███████╗║
║  ██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██║     ██║   ██║██╔════╝║
║  ██║  ██║███████║█████╗  ██║  ██║███████║██║     ██║   ██║███████╗║
║  ██║  ██║██╔══██║██╔══╝  ██║  ██║██╔══██║██║     ██║   ██║╚════██║║
║  ██████╔╝██║  ██║███████╗██████╔╝██║  ██║███████╗╚██████╔╝███████║║
║  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚══════╝║
║                                                                   ║
║  o  local-first · embedded router · multi-agent · not sentient o  ║
╚═══════════════════════════════════════════════════════════════════╝

Looking to build and sell your own AI CLI?

Check out Daedalus-Lite — the zero-dependency, rebrandable TypeScript starter template designed for developers to build, rebrand, and sell their own custom AI coding tools! Visit Daedalus-Lite →

Fun fact: Daedalus itself was built using Daedalus-Lite as a starting point, then extended with advanced features like multi-agent orchestration, codebase indexing, and autonomous workflows. See what's possible with Daedalus-Lite for inspiration.

Quick Start

npm install -g daedalus-cli
daedalus

To launch with the interactive terminal dashboard layout:

daedalus --tui

On first run, Daedalus scans for local LLM servers and guides you through setup. If none are found, it prompts for a remote provider.

From source: git clone https://github.com/bgill55/daedalus.git && cd daedalus && npm install && npm run build

Why Daedalus?

AI assistance without:

• Sending your code to third-party servers
• Per-token pricing for every interaction
• Being locked into a single provider
• Losing conversation history between sessions

Features

Core

• Interactive Terminal Dashboard (TUI) — premium side-by-side dashboard with real-time CPU/RAM monitor gauges, model selection overrides, and an interactive file tree to toggle prompt context dynamically.
• Local-first — works entirely on your machine with local LLMs
• Embedded model router — priority, round-robin, or fastest-response routing across multiple models with real-time tokens-per-second (tok/s) stream telemetry, plus Multi-Model Fallback for zero-interruption auto-failover on rate limits (429) or 5xx errors.
• Smart model tier routing — routes planning, reviews, and context summarization calls to your configured intelligence tier model
• Multi-agent orchestration — spawns planner, coder, reviewer, debugger, and researcher sub-agents
• Autonomous Finn Loop — interactive requirements gathering (/spec), GitHub Issues tracking, background daemon execution (daedalus --loop), and Discord PR review webhook embeds.
• Loop Engineering & Self-Repair — automatic stack-aware compile/build verification checks (e.g., npx tsc --noEmit, cargo check, go build) with dynamic stdout/stderr feedback loops for self-repair, Automated Workspace Rollback to revert patches upon task failure, and Git-Aware Smart Testing (/test -g) to run only affected unit tests in < 200ms.
• Codebase indexing & Live Watcher — FTS5-powered symbol search, definitions, and call-graph references across 10+ languages with background Live File-Watcher (/watch) for automatic re-indexing on save.
• MCP Marketplace & Explorer (/mcp explore) — Model Context Protocol server marketplace with one-click installation (/mcp install <name>) via stdio and HTTP/SSE.
• Stack-aware prompting — automatically scans your project tech stack on startup to prevent library and platform boundary hallucinations
• Dynamic task checklist — injects the active todo list into each prompt turn to maintain execution context
• Session management — SQLite-backed history with save, load, JSONL export
• Persistent memory — facts and coding conventions auto-inject every turn; /profile and /style persist across sessions
• Cursor & Claude Code Compatibility — automatically detects and inherits instructions from CLAUDE.md, .cursorrules, and .daedalusrules files in the project root on startup.
• MCP support — Model Context Protocol servers via stdio and HTTP/SSE
• Windows + Unix — full cross-platform support

Tools

• File tools — read, write, patch with interactive diff UI; fuzzy whitespace matching, syntax validation with auto-revert
• Trust layer — write-without-read guardrail, circuit breaker, import/export validation, auto-test loop, large-rewrite annotation
• Terminal — cross-platform shell execution (bash/cmd/powershell) with custom preference support, timeout, and abort
• Git — status, diff, stage-all-and-commit, undo
• Web — DuckDuckGo search and URL fetching (no API key needed)
• Image Generation — local Stable Diffusion WebUI integration with automatic zero-config Pollinations AI fallback (/image command & generate_image tool) for generating UI assets, logos, and graphics without requiring an API key
• Codebase — index, find, definitions, references
• Logger — unified src/tools/logger.ts with ConsoleLogger and SilentLogger for configurable output
• REPL — persistent context REPL (src/tools/repl.ts) for interactive experimentation
• Telemetry — lightweight performance timing utilities (src/tools/telemetry.ts)
• Dependency fallback — src/tools/deps.ts to verify required commands and provide helpful install guidance

Commands

Multi-Agent & Orchestration

Codebase Search & Live Watcher

Developer Tools, Git & MCP

Memory, Conventions & Config

Context & CLI Utilities

Additional Commands

Tab completion works on all commands. You can get detailed manuals, parameter lists, and subcommand options for any command directly inside the CLI by running /help <command> (for example, /help config or /help mcp).

Configuration

Daedalus stores config at ~/.daedalus/config.json. Key sections:

{
  "router": {
    "strategy": "priority",
    "chain": [
      { 
        "name": "local", 
        "endpoint": "http://localhost:1234/v1", 
        "model": "auto", 
        "enabled": true, 
        "priority": 1,
        "supportsTools": true,
        "tier": "intelligence"
      }
    ]
  },
  "indexing": { "enabled": true, "watch": true, "exclude": ["node_modules", "dist", ".git"] },
  "tools": { "sandbox": "none", "sandboxImage": "node:20" }
}

Router strategies: priority (default), round-robin, fastest.

Per-project config is stored at ~/.daedalus/config/<project-hash>.json and can be set via /project set <key> <value>.

Detailed Documentation Guides

For in-depth explanations, configuration options, and hardware optimization tips, see the modular guides below:

• Model Routing & Tuning Guide — Endpoints, failover chains, routing strategy configs, and GPU/LM Studio tuning recommendations.
• Multi-Agent Orchestration — Overview of the planning, coding, and review loops, recovery checkpoints, and background task runners.
• Autonomous Finn Loop — Interactive requirements specification, GitHub issue tracking, background daemon execution, and Discord webhook notifications.
• Execution Sandboxing — Running commands inside isolated Docker containers or WSL distributions.
• Model Context Protocol (MCP) Integration — Configuring stdio and HTTP/SSE servers to expand your agent's capabilities.
• Configuration Reference Guide — Reference list of all global configuration keys (router.*, agents.*, tools.*, ui.*, etc.).
• API Reference — Auto-generated TypeScript API documentation showing all exported classes, functions, and modules.

Development

npm run dev       # hot-reload
npm run build     # compile TypeScript
npm test          # vitest (470+ tests)
npm run lint      # eslint (flat config)
npx tsc --noEmit  # type check
npm run audit     # full CI pipeline (lint + build + test + config validation)
npm run docs      # generate Typedoc HTML documentation

Architecture

src/
├── index.ts           CLI entry, REPL, command dispatch
├── config/            Zod-schema validated config (+ validate.ts)
├── router/            Model routing, health checks, rate limiter
├── session/           SQLite sessions, project memory, JSONL export
├── agents/            Multi-agent orchestration (planner, coder, et al.)
├── tools/             Logger, REPL, telemetry, deps fallback, spinner
├── indexing/          FTS5 codebase indexing
└── onboarding/        Setup wizard

Contributing

See CONTRIBUTING.md for guidelines, coding standards, and the PR process. Governed by the Code of Conduct.

_{Daedalus is open source and free. If it helps you build cooler things faster, consider buying me a coffee!}

CHANGELOG.md | SECURITY.md | MIT License