Skip to content
Skills Library
AI & agents · Planning

daedalus

/daedalus

Plan and orchestrate coding work using the Daedalus CLI and Talos daemon. Daedalus is an AI planning CLI that creates structured beans (task files) for coding agents to execute autonomously. Use when planning features, breaking down work into tasks, or running autonomous agent workflows with beans.

Repository
skills ↗
Licence
MIT
Last repository change
08.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 08.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Plan and orchestrate coding work using the Daedalus CLI and Talos daemon. Daedalus is an AI planning CLI that creates structured beans (task files) for coding agents to execute autonomously. Use when planning features, breaking down work into tasks, or running autonomous agent workflows with beans.

Original author description

Plan and orchestrate coding work using the Daedalus CLI and Talos daemon. Daedalus is an AI planning CLI that creates structured beans (task files) for coding agents to execute autonomously. Use when planning features, breaking down work into tasks, or running autonomous agent workflows with beans.

How it works

  1. Overview
  2. Prerequisites
  3. Quick Start
  4. The daedalus CLI
  5. The talos CLI
  6. Configuration
  7. Beans
  8. Workflow
  9. Runtime Data
Original SKILL.md headings · 239 lines, 1,028 words
SKILL.md preview
---
name: daedalus
description: Plan and orchestrate coding work using the Daedalus CLI and Talos daemon. Daedalus is an AI planning CLI that creates structured beans (task files) for coding agents to execute autonomously. Use when planning features, breaking down work into tasks, or running autonomous agent workflows with beans.
license: MIT
compatibility: Requires Node.js >= 20 and the beans CLI (brew install hmans/beans/beans)
metadata:
  author: internet-development
  version: "1.0"
---

# Daedalus

## Overview

Daedalus is an AI planning CLI that creates structured tasks (beans) for coding agents to execute autonomously. Instead of babysitting agents, you plan the work with Daedalus and let Talos (the daemon) execute it.

- **Repository**: [internet-development/daedalus](https://github.com/internet-development/daedalus)
- **npm**: `npm install -g @internet-dev/daedalus`
- **Philosophy**: [A Beans Based AI Workflow](https://caidan.dev/blog/2026-01-29-a-beans-based-ai-workflow/)

The core insight: the bottleneck isn't agents — it's having clear enough tasks for them to work on.

```
You (planning) ──→ Daedalus ──→ Beans (.beans/) ──→ Talos ──→ Coding Agents
     ↑                                                              │
     └──────────── review PRs, iterate on plan ─────────────────────┘
```

## Prerequisites

- **Node.js** >= 20
- **beans CLI**: `brew install hmans/beans/beans` (or `go install github.com/hmans/beans@latest`)
- One of:
  - **Claude Code CLI** (recommended) — uses subscription, no API key
  - `ANTHROPIC_API_KEY` — direct Anthropic API
  - `OPENAI_API_KEY` — OpenAI alternative

## Quick Start

```bash
npm install -g @internet-dev/daedalus
cd your-project
beans init
daedalus
```

## The `daedalus` CLI

Interactive AI-assisted planning agent. Start a planning session:

```bash
daedalus                       # Session selector
daedalus --new                 # Fresh session
daedalus --continue            # Resume most recent
daedalus --mode brainstorm     # Start in brainstorm mode
daedalus tree                  # Show bean dependency tree
```

### Planning Modes

| Mode | Purpose |
|------|---------|
| `new` | Create new beans through guided conversation |
| `refine` | Improve and clarify existing draft beans |
| `critique` | Run expert review on draft beans |
| `sweep` | Check consistency across related beans |
| `brainstorm` | Explore design options with Socratic questioning |
| `breakdown` | Decompose work into actionable child beans (2-5 min each) |

### In-Session Commands

| Command | Action |
|---------|--------|
| `/help` | Show all commands |
| `/mode [name]` | Switch planning mode |
| `/prompt [name]` | Select a built-in prompt |
| `/edit` | Open `$EDITOR` for multi-line input |
| `/sessions` | List and switch sessions |
| `/new` | Start a new session |
| `/tree` | Display bean tree |
| `/start` / `/stop` | Start/stop Talos daemon |
| `/status` | Show daemon status |
| `/quit` | Exit |

### Expert Advisors

Daedalus can consult 9 expert personas for multi-perspective analysis:

| Expert | Focus |
|--------|-------|
| Pragmatist | Ship fast, avoid over-engineering |
| Architect | Scalability, maintainability, long-term health |
| Skeptic | Edge cases, failure modes, what could go wrong |
| Simplifier | Reduce complexity, find simpler alternatives |
| Security | Auth, data exposure, input validation, attack vectors |
| Researcher | Papers, docs, best practices |
| Codebase Explorer | Patterns, dependencies, existing architecture |
| UX Reviewer | User experience, discoverability, interface design |
| Critic | Synthesize multiple perspectives into actionable feedback |

## The `talos` CLI

Talos is the daemon that watches `.beans/` and spawns coding agents to work on todo beans. Named after the bronze automaton that protected Crete.

```bash
talos start              # Start daemon (background)
talos start --no-detach  # Start in foreground
talos stop               # Stop daemon
talos stop --force       # Force kill
talos status             # Show daemon status
talos logs               # View recent logs
talos logs -f            # Follow logs
talos config             # Show configuration
talos config --validate  # Validate talos.yml
```

### The Ralph Loop

Talos runs a [ralph loop](https://www.humanlayer.dev/blog/brief-history-of-ralph):

1. **Pick a bean** — Query todo/in-progress beans, filter blocked ones, sort by priority
2. **Mark in-progress** — Update bean status
3. **Generate prompt** — Implementation prompt for tasks/bugs, review prompt for epics
4. **Run agent** — Claude Code, OpenCode, or Codex
5. **Handle result** — On success, check status. On failure, retry up to 3 times
6. **Pick next** — Repeat until no beans remain

## Configuration

Create `talos.yml` in your project root:

```yaml
agent:
  backend: claude
  claude:
    model: claude-sonnet-4-20250514

planning_agent:
  provider: claude_code
  model: claude-sonnet-4-20250514

planning:
  skills_directory: ./skills
  modes:
    brainstorm:
      skill: beans-brainstorming
    breakdown:
      skill: beans-breakdown
```

### Agent Backends

| Backend | Command | API Key Required |
|---------|---------|-----------------|
| `claude` | Claude Code CLI | No (uses subscription) |
| `opencode` | OpenCode CLI | No (uses subscription) |
| `codex` | OpenAI Codex CLI | Yes (`OPENAI_API_KEY`) |

### Planning Providers

| Provider | Description |
|----------|-------------|
| `claude_code` | Claude Code CLI (recommended, no API key) |
| `claude` | Anthropic API (requires `ANTHROPIC_API_KEY`) |
| `openai` | OpenAI API (requires `OPENAI_API_KEY`) |
| `opencode` | OpenCode CLI |

## Beans

Beans are plain markdown files with YAML front matter, stored in `.beans/` and tracked in git.

```markdown
---
id: daedalus-abc123
title: Add user authentication
type: feature
status: todo
priority: high
parent: daedalus-parent-id
blockedBy:
  - daedalus-other-id
---

## Problem

Users can't log in...

## Solution

Implement email + password auth...

## Files

- `src/auth/login.ts` - Login handler
- `src/auth/session.ts` - Session management
```

### Bean Types

| Type | Use For |
|------|---------|
| `milestone` | Release target with deadline |
| `epic` | Thematic group of related work |
| `feature` | User-facing capability |
| `bug` | Something broken to fix |
| `task` | Concrete implementation work |

### Bean Statuses

| Status | Meaning |
|--------|---------|
| `draft` | Not ready for execution |
| `todo` | Ready to be picked up |
| `in_progress` | Currently being worked on |
| `done` | Completed |

### Bean Commands

```bash
beans create "Title" -t task -s todo -d "Description..."
beans update <id> --status done
beans update <id> --parent <parent-id>
beans update <id> --blocking <other-id>
beans query '{ beans { id title status } }'
```

## Workflow

The recommended workflow with Daedalus:

1. **Plan** — `daedalus --mode brainstorm` to explore the design space
2. **Break down** — `daedalus --mode breakdown` to decompose into small beans
3. **Critique** — `daedalus --mode critique` to get expert feedback
4. **Execute** — `talos start` to let agents work autonomously
5. **Review** — Check agent output, refine beans, plan next batch

## Runtime Data

The `.talos/` directory (gitignored) stores:

| Path | Contents |
|------|----------|
| `.talos/output/` | Agent execution logs |
| `.talos/chat-history.json` | Planning chat persistence |
| `.talos/prompts/` | Custom planning prompts |
| `.talos/daemon.pid` | Daemon process ID |
| `.talos/daemon-status.json` | Daemon state |

Versions

The database has no other skills named daedalus.

Database snapshot: 13.11.2026 · package version ba97e4ea3ffa (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100build-vs-buy-boundary
    Decides build vs buy for each component of an AI product: what the studio platform (Daedalus) provides and the fellow inherits, what the fellow must build as their moat, and what to rent, in a boundary map. Use when the user asks whether to build their own eval harness, RAG…
  • 95talos-helper
    Talos Linux cluster administration using talosctl When user mentions Talos, talosctl, or Talos cluster operations
  • 100claude-devfleet
    Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports. Use when dispatching parallel coding agents across isolated worktrees and tracking their reports.
  • 90argentos-claude-code
    Delegate coding tasks to Claude Code (Anthropic's CLI agent). Use for building features, refactoring, PR reviews, and iterative coding. Requires the claude CLI installed.
  • 100autonomous-coding-agents
    Delegate coding, refactoring, PR review, and long-running implementation work to autonomous coding CLIs such as Claude Code, Codex, and OpenCode. Use when deciding which coding agent CLI to run, orchestrating one-shot or interactive sessions, handling PTYs/tmux/background…
  • 100ao-orchestrator
    Use when acting as the multi-project orchestrator and lead coordinator across repositories using the Agent Orchestrator (AO) daemon. Spawns, inspects, coordinates, and reviews parallel coding agents in isolated Git worktrees.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.