Build With Agents That Remember
_{✦ A Collective Intelligence Runtime ✦}

Why Sibyl? • Quickstart • Agents • CLI • Web UI • FAQ

AI agents that remember everything. A collective intelligence that compounds with every session. Orchestration that lets you manage a fleet of autonomous agents—all building on shared knowledge, all tracked in one place.

Today's agents have amnesia. Every session starts fresh. No memory of what worked, what failed, what you learned yesterday. Multiple agents across different features? Chaos.

Sibyl changes that.

A knowledge graph gives your agents persistent memory. Epics and tasks structure your work. Spawn agents that execute autonomously while you approve decisions and track progress. Solo dev? Your agents become your team. Actual team? Everyone's insights compound.

The whole becomes greater than the sum of its parts.

Dashboard	Projects
Knowledge Graph	Task Workflow

curl -fsSL https://raw.githubusercontent.com/hyperb1iss/sibyl/main/install.sh | sh

Installs uv (if needed), installs sibyl-dev, starts Sibyl. Done.

uv tool install sibyl-dev
sibyl local start

pipx install sibyl-dev
sibyl local start

sibyl local start    # Start all services
sibyl local stop     # Stop services
sibyl local status   # Show running services
sibyl local logs     # Follow logs
sibyl local reset    # Nuke and start fresh

# One-line setup (installs proto, moon, toolchain, dependencies)
./setup-dev.sh

# Or manually:
curl -fsSL https://moonrepo.dev/install/proto.sh | bash
proto use                  # Installs node, pnpm, python, uv
proto install moon
uv sync && pnpm install

# Configure
cp apps/api/.env.example apps/api/.env
# Add SIBYL_OPENAI_API_KEY + SIBYL_JWT_SECRET

# Launch everything
moon run dev

# Verify
curl http://localhost:3334/api/health

Ports:

Sibyl's flagship feature: spawn AI agents that work autonomously while you review and approve their actions.

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Web UI    │────▶│   Sibyl     │────▶│   Claude    │
│  (approve)  │◀────│  (orchestr) │◀────│   (agent)   │
└─────────────┘     └─────────────┘     └─────────────┘
       │                   │                   │
       │                   ▼                   │
       │           ┌─────────────┐             │
       └──────────▶│  Knowledge  │◀────────────┘
                   │    Graph    │
                   └─────────────┘

1. Spawn agents from the web UI or CLI with a task description
2. Agents work autonomously using Claude SDK with your knowledge graph as context
3. Human-in-the-loop approvals for destructive operations, sensitive files, external APIs
4. Progress streams in real-time via WebSocket to the chat UI
5. Checkpoints save state so agents can resume after interruptions

• Task Assignment — Agents claim tasks and update status automatically
• Git Worktrees — Each agent works in an isolated worktree to prevent conflicts
• Approval Queue — Review and approve/deny agent actions before execution
• Cost Tracking — Monitor token usage and USD cost per agent
• Checkpointing — Save/restore agent state for crash recovery
• Multi-Agent — Multiple agents can collaborate on related tasks

Web UI: Navigate to /agents → Click "Spawn Agent" → Describe the task

CLI:

sibyl agent spawn --task task_abc123 "Implement the OAuth flow"

REST API:

curl -X POST http://localhost:3334/api/agents \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"prompt": "Implement OAuth", "task_id": "task_abc123"}'

The CLI is the power-user interface. Clean output, optimized for scripting and AI agent consumption.

# Install globally
moon run install-cli

# Or use directly
uv tool install sibyl-cli

# Search your knowledge
sibyl search "authentication patterns"
sibyl search "OAuth" --type pattern

# Add knowledge
sibyl add "Redis connection pooling" "Pool size must be >= concurrent requests to avoid blocking"

# Task workflow
sibyl task list --status todo,doing
sibyl task start task_abc
sibyl task complete task_abc --learnings "Key insight: always check TTL first"

# Explore the graph
sibyl explore related ent_xyz    # Find connected entities
sibyl explore communities        # View knowledge clusters

backlog ──▶ todo ──▶ doing ──▶ review ──▶ done ──▶ archived
                       │
                       ▼
                    blocked

sibyl task list                  # JSON (default, for scripts)
sibyl task list --table          # Human-friendly table
sibyl task list --csv            # For spreadsheets

A full admin interface at http://localhost:3337:

• Dashboard — Stats overview, recent activity, quick actions
• Agents — Spawn, monitor, and chat with AI agents
• Tasks — Kanban-style workflow with inline editing
• Graph — Interactive D3 visualization of knowledge connections
• Search — Semantic search with filters
• Sources — Configure documentation crawling
• Settings — Organizations, API keys, preferences

Built with: Next.js 16, React 19, React Query, Tailwind CSS, SilkCircuit design system

Connect Claude Code, Cursor, or any MCP client to Sibyl:

{
  "mcpServers": {
    "sibyl": {
      "type": "http",
      "url": "http://localhost:3334/mcp",
      "headers": {
        "Authorization": "Bearer sk_your_api_key"
      }
    }
  }
}

Sibyl ships with skills and hooks for seamless Claude Code integration.

Install:

moon run skills:install    # Install /sibyl skill
moon run hooks:install     # Install context hooks

/sibyl skill — Full CLI access from Claude Code:

/sibyl search "authentication patterns"
/sibyl task list --status doing
/sibyl add "OAuth insight" "Token refresh needs..."

Hooks — Automatic context injection:

The UserPromptSubmit hook extracts keywords from your prompt, searches Sibyl, and injects matching patterns as context—so Claude always knows what you've learned before.

See skills/ and hooks/ for implementation details.

sibyl/
├── apps/
│   ├── api/              # FastAPI + MCP server (sibyld)
│   ├── cli/              # REST client CLI (sibyl)
│   └── web/              # Next.js 16 frontend
├── packages/python/
│   └── sibyl-core/       # Shared library (models, graph, tools)
├── skills/               # Claude Code skills
├── charts/               # Helm charts for K8s
└── docs/                 # Documentation

Stack:

• Backend: Python 3.13 / FastMCP / FastAPI / Graphiti / FalkorDB
• Frontend: Next.js 16 / React 19 / React Query / Tailwind 4
• Database: FalkorDB (graph) + PostgreSQL (relational)
• Build: moonrepo + uv (Python) + pnpm (TypeScript)
• Agents: Claude SDK with human-in-the-loop approvals

SIBYL_JWT_SECRET=your-secret-key    # Required
SIBYL_JWT_EXPIRY_HOURS=24            # Optional

# Create via CLI
sibyl auth api-key create --name "CI/CD" --scopes mcp,api:read

# Scopes: mcp, api:read, api:write

SIBYL_GITHUB_CLIENT_ID=...
SIBYL_GITHUB_CLIENT_SECRET=...

docker compose -f docker-compose.prod.yml up -d

helm install sibyl ./charts/sibyl \
  --set backend.existingSecret=sibyl-secrets \
  --set backend.database.existingSecret=sibyl-postgres

See docs/deployment/ for detailed guides:

• Docker Compose
• Kubernetes
• Environment Variables

# Start everything
moon run dev

# Individual services
moon run dev-api          # API + worker
moon run dev-web          # Frontend only

# Quality checks
moon run api:test         # Run API tests
moon run api:lint         # Lint
moon run web:typecheck    # TypeScript check
moon run core:check       # Full check on core library

# Database
moon run docker-up        # Start FalkorDB + PostgreSQL
moon run docker-down      # Stop databases

Solo developers who want a team of AI agents working on their codebase—with memory that persists. Teams who want shared knowledge that compounds. Anyone building with AI who's tired of repeating context every session.

No. The knowledge graph and task system work great standalone—for documentation, task tracking, and capturing learnings. But agents are where Sibyl really shines: autonomous workers that share memory and coordinate through your graph.

Sibyl is self-hosted and open source—you own your data. It includes a full task workflow system, not just memory. It has a web UI for humans, not just APIs for machines. And it provides agent orchestration with approvals, not just memory storage.

• OpenAI (required): For embeddings (text-embedding-3-small)
• Anthropic (optional): For agent orchestration and entity extraction

A typical solo developer uses ~$5/month in API costs.

Yes. Organizations have isolated graphs with role-based access. Multiple users can share knowledge, assign tasks, and collaborate on the same graph.

Sibyl is in active development (v0.1.x). The core features work well, but expect rough edges. We use Sibyl to build Sibyl—every feature, task, and learning you see here was tracked and orchestrated through the system itself.

Where we're headed:

• Multi-vendor agents — Orchestrate Claude, Codex, Gemini, and future models from one place
• Meta-orchestrator — A higher-order agent that manages your fleet: distributing tasks, monitoring progress, responding to your plans
• Brainstorming spaces — Dedicated areas for ideation before execution
• External data connectors — Feed more sources into the collective intelligence
• Deeper reasoning — Multi-hop graph traversal, community-based retrieval, agentic reflection

The collective gets smarter. The orchestration gets deeper.

The graph knows things. Before you code:

sibyl search "what you're building"
sibyl search "error you hit" --type episode

Never do significant work outside a task. Tasks provide traceability, progress tracking, and knowledge linking.

If it took time to figure out, save it:

sibyl add "Descriptive title" "What, why, how, caveats"

Bad: "Fixed the bug" Good: "JWT refresh fails when Redis TTL expires. Root cause: token service doesn't handle WRONGTYPE. Fix: try/except with regeneration fallback."

sibyl task complete <id> --learnings "Key insight: ..."

The graph should be smarter after every session.

We welcome contributions! See CONTRIBUTING.md for guidelines.

# Fork, clone, then:
./setup-dev.sh
moon run dev

# Make changes, then:
moon run :check           # Lint + typecheck + test

AGPL-3.0 — See LICENSE

<sub>If Sibyl helps your agents remember, give us a ⭐ or support the project

✦ Built with obsession by Hyperbliss Technologies ✦</sub>