🏰 Camelot AI

Delegate coding tasks to AI agents. Manage them from a kanban board.

🏰 Camelot AI gives development teams a way to safely scale their engineering output
with AI — without giving up control. Create tasks on a board, let AI agents plan
and implement them, review and approve before anything ships. Like having junior
developers who never sleep, managed through a clean visual interface.

How It Works

1. Create tasks on a kanban board — or sync them from GitHub Issues
2. AI agents pick up tasks, write a plan, and wait for your approval
3. You approve the plan — agents execute it and open a PR
4. Watch it happen in real-time with live session streaming
5. Review the PR, merge, done — agents handle reviewer comments and CI failures too

Features

• Kanban board — 6-stage workflow: todo, planning, executing, pr, done, cancelled. Set priorities, track state at a glance.
• Multi-agent coordination — Run Claude Code and Codex agents in parallel across projects. Priority-based task dispatch.
• Human-in-the-loop — Agents propose plans before writing code. You approve before anything ships. No surprise commits.
• GitHub-native — Sync issues as tasks, track PRs, monitor CI checks. Tasks auto-complete when PRs merge.
• Customizable prompts — Per-project prompt templates with {{variable}} interpolation. Tune agent behavior to match your conventions.
• Tool permissions — Whitelist which CLI tools agents can use. Full control over agent capabilities.
• Real-time streaming — Watch agent output live via WebSocket. Full session logs for every execution.
• Self-hosted — Your code never leaves your infrastructure. PostgreSQL on your servers. No SaaS dependency.
• Magic link auth — No passwords to manage. Email-based authentication out of the box.

Tech Stack

Getting Started

Prerequisites

• Elixir >= 1.15 and Erlang/OTP (use asdf or mise for version management)
• PostgreSQL >= 14
• An SSH key is auto-provisioned per user; a GitHub App is optional and
  admin-configured for PR/issue polling — see
  docs/self-hosting/github-app.md
• Claude Code and/or Codex CLI installed

Installation

# Clone the repo
git clone https://github.com/T0ha/camelot.git
cd camelot

# Install dependencies, create DB, run migrations, build assets
mix setup

# Generate a secret key
mix phx.gen.secret
# Set it as SECRET_KEY_BASE in your environment

# Start the server
iex -S mix phx.server

Visit localhost:4000.

First Steps

1. Sign in with a magic link sent to your email
2. Create a project pointing to a local git repository
3. Create a task, pick a CLI Agent (Claude Code or Codex) from the
   dropdown, and watch it flow through the board

See Get Started (source:
docs/cloud/get-started.md) for a full
walkthrough from first login to your first merged PR.

Configuration

Key environment variables (see config/runtime.exs for full details):

Bootstrapping users

When REGISTRATION_ENABLED=false (cloud beta mode), the sign-in screen rejects unknown emails. Use the mix task to add users — the first invocation creates an admin who can then add more users from /admin/users:

# First admin (bootstrap)
mix camelot.create_user [email protected]

# Subsequent users
mix camelot.create_user [email protected] --role user

Inside a release:

bin/camelot eval 'Mix.Tasks.Camelot.CreateUser.run(["[email protected]"])'

Architecture

Agent CLI ──→ Tasks ──→ Sessions
                 │
Projects ────────┤
                 │
           PromptTemplates

• Projects map to local git repositories with optional GitHub integration
• Agent CLI configs wrap a CLI tool (Claude Code or Codex) — executable, args, parser, runner image — configured once (admin-only) and picked per task
• Tasks pick a fixed Agent CLI at creation and flow through a state machine: draft → todo → planning → executing → pr → done
• Sessions record each execution of a task, driven by a TaskRunner process, with full output logs
• Prompt Templates are customizable per-project with variable interpolation

Key modules: Camelot.Board.Task, Camelot.Agents.Agent,
Camelot.Runtime.TaskRunner, Camelot.Projects.Project,
Camelot.Prompts.PromptTemplate

Development

mix test              # Run tests
mix format            # Format code
mix credo             # Lint
mix dialyzer          # Type checking
mix precommit         # All checks before committing

See CLAUDE.md and AGENTS.md for AI-assisted development guidelines.

Deployment

🏰 Camelot AI is a standard Phoenix application. See the
Phoenix deployment guides
for general instructions.

Run docker compose up to deploy with the included Dockerfile and
docker-compose.yml.

Roadmap

• Kanban board with full task lifecycle
• Claude Code and Codex agent support
• GitHub issue sync and PR tracking
• Prompt template customization
• Real-time session streaming
• Tool permission controls
• Docker / docker-compose deployment
• Webhook-based GitHub integration
• Additional agent types
• Team / multi-user collaboration
• 🏰 Camelot AI Cloud (hosted version)

Contributing

PRs welcome — see the roadmap above for ideas.

• Branch off develop and open your PR against develop — main is
  release-only and is updated through an automatic develop → main PR
• Follow the Elixir Style Guide
• Run mix precommit, mix credo and mix dialyzer before submitting
• Open an issue first for large changes

Branching model, CI pipelines and the release flow are documented in
docs/contributing.md.

License

GPL-2.0

camelotai.tech