Kage enables Claude Code agents to work autonomously while you're away, share context with each other, and scale across multiple repositories.

Quick Start

# Install via script
curl -fsSL https://kage.raskell.io/install.sh | sh

# Or via Cargo
cargo install kage

# Or via Docker
docker pull ghcr.io/raskell-io/kage:latest

# Run
kage daemon start
kage agent spawn --repo ~/code/myproject

Features

Why Kage

Running a single Claude Code session is straightforward. But what happens when you need agents working across multiple repositories? When you want to step away and let them work autonomously? When they need to share what they've learned?

Kage solves these problems with a supervisor architecture:

• Spawn agents with specific goals — Give your agents clear objectives and let them work
• Monitor health and progress — Track what your agents are doing in real-time
• Enforce iteration limits — Set guardrails to prevent runaway execution
• Checkpoint and resume — Save state, review progress, provide guidance, and continue

Architecture

┌─────────────────────────────────────────────────────┐
│                   Kage Daemon                       │
├─────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  │
│  │   Agent 1   │  │   Agent 2   │  │   Agent 3   │  │
│  │  (Claude)   │  │  (Claude)   │  │  (Claude)   │  │
│  └─────────────┘  └─────────────┘  └─────────────┘  │
│                                                     │
│  ┌───────────────────────────────────────────────┐  │
│  │              Memory Store                     │  │
│  │  ┌──────────────┐  ┌──────────────┐           │  │
│  │  │   Working    │  │  Long-term   │           │  │
│  │  │   Memory     │  │   Memory     │           │  │
│  │  └──────────────┘  └──────────────┘           │  │
│  └───────────────────────────────────────────────┘  │
│                                                     │
│  ┌───────────────────────────────────────────────┐  │
│  │           Subscription Pool                   │  │
│  │  ┌────┐ ┌────┐ ┌────┐ ┌────┐                  │  │
│  │  │ S1 │ │ S2 │ │ S3 │ │ S4 │  ...             │  │
│  │  └────┘ └────┘ └────┘ └────┘                  │  │
│  └───────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

Configuration

Kage uses TOML for configuration with layered precedence:

CLI flags > Environment > Task-specific > Namespace > Global

# ~/.config/kage/config.toml

[daemon]
socket = "/tmp/kage.sock"
log_level = "info"

[defaults]
max_iterations = 50
checkpoint_interval = 10

[namespaces.backend]
repos = [
    "~/code/api-server",
    "~/code/auth-service",
]
memory_sharing = "full"

CLI Reference

Daemon

kage daemon start       # Start the daemon
kage daemon stop        # Stop the daemon
kage daemon status      # Check daemon status

Agents

kage agent spawn        # Spawn a new agent
kage agent list         # List active agents
kage agent attach <id>  # Attach to an agent
kage agent kill <id>    # Kill an agent

Tasks

kage task add "<goal>"  # Add a new task
kage task list          # List tasks
kage task status <id>   # Check task status
kage task resume <id>   # Resume a paused task

Memory

kage memory search "<query>"  # Search memories
kage memory list              # List recent memories
kage memory inject <target> --from <source>  # Share context

File Locations

Secrets (API keys) are stored in your OS keychain, never in plaintext files.

Built With

• Rust — Memory-safe, fast, and reliable
• Tokio — Async runtime
• redb — Embedded key-value store (pure Rust)
• tonic — gRPC framework
• ratatui — Terminal UI

Documentation

Full documentation is available at kage.raskell.io/docs.

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

Apache 2.0 — see LICENSE for details.

Related Projects

• Claude Code — The primary AI agent supported by Kage
• Sentinel — Security-first reverse proxy from raskell.io