Self-hosted control plane for AI coding agents. Orchestrate Claude Code, Codex, Vibe, Gemini CLI, Kiro, GitHub Copilot, and Ollama (local models) — with less waste.
Enter the grid. Command your agents.
Early development — Kronn is functional but actively evolving. Expect breaking changes.
You use AI coding agents. Maybe Claude Code, maybe Codex, maybe both. Each has its own config, its own MCP setup, its own context files scattered across your repos. You manage all of that... manually.
Kronn fixes that. Every feature is designed to reduce unnecessary compute — document once instead of letting agents explore blindly, persist context instead of rebuilding it from scratch, frame agents with profiles and skills so they get it right on the first try.
| Without Kronn | With Kronn | |
|---|---|---|
| Agents | Switch between 3+ CLIs, each with different flags | One dashboard, all agents, @mentions |
| MCPs | Maintain separate configs per agent per repo | Configure once, sync to all projects and all agents |
| Architecture decisions | Ask one model, get one opinion | Multi-agent debate: agents argue, then synthesize |
| Recurring tasks | Run manually, forget, repeat | Cron workflows with multi-step, multi-agent pipelines |
| Legacy projects | "Nobody knows how this works" | 20-min AI audit → fully documented, AI-ready codebase |
| Tokens | No idea what you're spending | Per-message cost tracking, usage dashboard with daily history, provider breakdown, project-level visibility |
| API Keys | One key per provider, no switching | Multiple named keys per provider with one-click activation |
| Security | Tokens in plaintext in dotfiles | AES-256-GCM encrypted, self-hosted, nothing leaves your network |
| Waste | Agents explore blindly, rebuild context daily, retry on bad answers | Document once, persist context, get it right first try |
Download, install, launch. No Docker, no CLI, no config.
Download latest release — .msi (Windows), .dmg (macOS), .deb / .AppImage (Linux).
The setup wizard detects your agents and repositories automatically.
For those who want full control, multi-user P2P sync, or server deployment.
Prerequisites: Docker + Docker Compose. Windows requires WSL2.
git clone https://github.com/DocRoms/kronn.git
cd kronn
./kronn start
# → open http://localhost:3140Full installation guide (Linux / macOS / Windows)
Chat with agents in project context. Use @claude or @codex to target specific agents. Debate mode: agents discuss in configurable rounds (1-3) and a primary agent synthesizes.
Persistent conversations backed by SQLite. Full i18n (French, English, Spanish). Claude Code streamed token-by-token with per-message tracking. Switch agent mid-conversation — click the agent name to switch; the new agent auto-summarizes and continues. Favorites — pin any discussion (star icon in header) to a dedicated "Favorites" section at the top of the sidebar. Unread badges on individual discussions AND group headers — never lose track of new messages. Archive, retry, edit, search, swipe gestures, multi-line input, emoji autocomplete (:tada: → 🎉).
Share discussions between Kronn instances via WebSocket. Replicated model: each peer stores a full copy, messages sync in real-time. Auto-detection of Tailscale, VPN, and LAN networks. Network diagnostics on connection failures.
A 3-tier architecture with encrypted secrets, now covering two kinds of plugins:
Plugin (MCP / API / hybrid) → Config (instance + secrets) → Project (N:N)
56 built-in plugins — 53 MCPs + 3 API plugins (Chartbeat, Adobe Analytics, Google Search). MCPs expose tools to the agent via .mcp.json sync; API plugins ship their endpoints + auth + curl example directly into the agent's system prompt, so the agent calls them via Bash (no MCP server required). OAuth2 client-credentials is supported out of the box (Adobe IMS today, extensible to Google Analytics / Salesforce / any RFC 6749 provider): Kronn mints + caches the bearer token, the agent never sees the secret. A single plugin can offer both MCP and API (hybrid) — useful for services like Jira that have an MCP server AND a REST API. Full list →
- Auto-detection from existing
.mcp.jsonfiles across projects - Disk sync for MCP plugins —
.mcp.json(Claude),.kiro/settings/mcp.json(Kiro),.gemini/settings.json(Gemini),.vibe/config.toml(Vibe),~/.codex/config.toml(Codex),~/.copilot/mcp-config.json(Copilot) - Prompt injection for API plugins — no
.mcp.jsonwrite; a## REST APIs availablesection with credentials + endpoints + curl template appears in the agent's--append-system-prompt - Smart dedup — detects when the same MCP uses different runtimes (e.g. npm package vs Go binary) and merges them automatically
- Inline secret editing with per-field visibility toggles; API plugins' non-secret config keys (host, workspace id, etc.) render as plain text with placeholders + descriptions sourced from the plugin definition
- Global configs — mark a config as global to deploy to all projects at once
- Kind filter in the Plugins UI:
All | 🔌 MCP | 🌐 APIpills above the category row
One system for everything: cron jobs, multi-step pipelines, issue-to-PR automation, manual triggers, and webhook notifications (Notify step — zero tokens, direct HTTP call). Created from a 5-step UI wizard or imported from a WORKFLOW.md file. MCP tools auto-injected into agent prompts.
Level 1 — Simple cron: one agent, one prompt, on a schedule.
---
trigger: { cron: "0 2 * * 1" }
agent: claude-code
---
Audit all dependencies for known vulnerabilities.Level 2 — Multi-step, multi-agent: chain steps, different agents per step, debates.
---
trigger: { cron: "0 9 * * *" }
steps:
- name: scan
agent: claude-code
mcps: [filesystem]
prompt: "List all TODO/FIXME comments in the codebase."
- name: prioritize
agents: [claude-code, codex]
mode: debate
rounds: 2
prompt: "Rank these TODOs by business impact and effort."
- name: report
agent: claude-code
prompt: "Generate a markdown report and create a GitHub issue."
---Level 3 — Tracker-driven (Issue → PR) and Level 4 — Manual trigger: see Workflow documentation.
Symphony compatibility
Kronn reads OpenAI Symphony's WORKFLOW.md natively. Existing users can migrate without changes. Kronn extends the pattern with: any trigger (cron, GitHub/Linear/GitLab/Jira, manual), any agent per step, debate mode, auto-injected MCPs, dashboard UI, and per-run token tracking.
Three independent axes shape how agents behave — all multi-selectable, all available in discussions and workflow steps:
Profiles (WHO) — 17 built-in personas with distinct perspectives and avatars.
| Category | Profiles |
|---|---|
| Technical | Architect, Tech Lead, QA Engineer, Game Developer, Staff Engineer |
| Business | Product Owner, Scrum Master, Technical Writer, Entrepreneur, UX Designer, Translator/Teacher |
| Data | Data Analyst, Data Engineer |
| Operations | SRE/DevOps, SEO/Growth |
| Meta | Devil's Advocate, Mentor |
Skills (WHAT) — 25 built-in domain expertise, injected as knowledge.
| Category | Skills |
|---|---|
| Language | Rust, TypeScript, Python, Go, PHP, Java, Kotlin, Swift, C# |
| Domain | Security, DevOps, Data Engineering, Database, Terraform/IaC, Testing, API Design, Mobile |
| Business | SEO, Web Performance, Green IT, Accessibility, GDPR |
Directives (HOW) — control output format and verbosity. Conflict detection prevents contradictory combinations.
Custom profiles, skills, and directives are Markdown files with YAML frontmatter in ~/.config/kronn/. Create, edit, and delete from the dashboard.
Generate, review, and validate AI context documentation for any project in 4 steps:
NoTemplate → TemplateInstalled → Audited → Validated
- Install template — one-click
ai/skeleton with redirectors (CLAUDE.md,.cursorrules,.windsurfrules) - AI audit — 10-step automated analysis (~20 min, SSE progress) with 3 expert profiles: project analysis, repo map, coding rules, testing, architecture, glossary, operations, MCP servers, tech debt, final review
- Validation — interactive Q&A where the AI asks about ambiguities and updates docs in real-time
- Mark as validated — project is AI-ready
Optional pre-audit briefing: 5 quick questions about purpose, stack, team, conventions, and watch points.
Drift detection: compares source file checksums against stored data, reports stale sections without consuming tokens. Partial re-audit re-runs only stale steps.
Talk to your agents. No cloud, no API, no data leaves your machine.
- Speech-to-Text — Whisper WASM via
@huggingface/transformers. Three model sizes (Tiny/Base/Small). - Text-to-Speech — Piper WASM via
@diffusionstudio/vits-web. 9 voices across FR/EN/ES. - Voice Conversation Mode — hands-free loop: speak → send → agent responds → TTS reads → mic auto-starts.
All models downloaded on first use and cached locally.
- Usage Dashboard — real-time token consumption and cost estimation across all providers. Summary cards, provider breakdown bar, per-project horizontal bars, daily history chart (30 days, stacked by provider). Toggle between token count and USD cost view. Filter by discussions or workflows. Click a discussion name to navigate directly to it
- Project Bootstrap — create a new project from scratch with an AI architect guiding Vision → Architecture → Stack → MVP → Action Plan
- Worktree Isolation + Test Mode — each discussion/workflow runs in its own git worktree. One-click 🧪 Test mode (0.5) swaps your main repo to the discussion's branch so you can try the code in your IDE without leaving Kronn; the agent is paused, a global banner shows the active test, and exiting restores your previous branch + pops the auto-stash + re-creates the worktree. Triple preflight (worktree dirty, main dirty, detached HEAD) with a modal that lets you pick stash and proceed / commit first / cancel — rollback on any failure
- Agent Incompatibility — Kronn tracks per-agent limitations and auto-excludes incompatible agents from steps
- Guided Tour — 17-step interactive onboarding for new users. Auto-launched on first visit, replayable from "?" button. 4 learn-by-doing steps where the user clicks the real UI (pulse animation). Spotlight overlay with auto-positioned tooltips. Keyboard navigation (Escape/arrows). Mobile-responsive
- Secret unlock area — a hidden zone in Settings (revealed by a well-known arcade input sequence entered on the Settings page) accepts short codes that ship with each release. A single code can unlock a theme, a profile, or both at once. Lets the maintainer ship early-access palettes and personas for testers without exposing them in the default UI. Codes are never distributed with the source — only their hashes
| Agent | CLI | Status |
|---|---|---|
| Claude Code | claude |
✅ Supported |
| OpenAI Codex | codex |
✅ Supported |
| Vibe | vibe |
✅ Supported (CLI + direct Mistral API) |
| Gemini CLI | gemini |
✅ Supported |
| Kiro | kiro-cli |
✅ Supported |
| GitHub Copilot | copilot |
✅ Supported |
| Ollama (local) | ollama |
✅ Supported (100% local, zero cost) |
| DeepSeek | deepseek |
Planned |
| OpenCode | opencode |
Planned |
Auto-detected at setup with runtime probe fallback (npx). Per-agent permissions toggle. Multiple named API keys per provider. Ollama: runs models locally (Llama, Gemma, Codestral, Qwen) — setup wizard in Settings with health check, model suggestions, and contextual install instructions per OS.
./kronn start # Interactive flow: detect agents, choose CLI or web
./kronn start --debug # Same + verbose backend logs auto-tailed in terminal
./kronn stop # Stop all services
./kronn restart # Stop and restart services
./kronn web # Launch web interface directly
./kronn logs # View service logs (Ctrl+C to detach)
./kronn status # Overview (delegates to API when backend is up)
./kronn agents # List detected agents (API-first, local fallback)
./kronn projects # List projects with audit status (requires backend)
./kronn init [path] # Configure AI context for a repo
./kronn mcp sync # Sync MCP configs across repos
./kronn help # Show helpDev commands
make start # Build & launch (Docker)
make start DEBUG=1 # Same, with verbose backend logs (debug level)
make stop # Stop services
make logs # Tail logs (all services)
make dev-backend # Rust hot reload
make dev-frontend # Vite dev server
make typegen # Sync Rust → TS types
make bump V=x.y.z # Bump version everywherekronn/
├── backend/ # Rust (Axum) — API, workflows, agents, SQLite
│ └── src/
│ ├── api/ # setup, projects, agents, mcps, workflows, discussions, contacts
│ ├── core/ # config, scanner, registry, crypto, cmd helpers, profiles, directives
│ ├── agents/ # Agent runner (spawns CLIs, streams stdout)
│ ├── workflows/ # Workflow engine, triggers, steps
│ ├── skills/ # 25 built-in (Markdown + YAML frontmatter)
│ ├── profiles/ # 17 built-in agent profiles
│ └── directives/ # Output directives
├── frontend/ # React 19 + TypeScript + Vite
│ └── src/
│ ├── pages/ # SetupWizard, Dashboard, Settings, Discussions, MCPs, Workflows
│ ├── types/ # generated.ts (from Rust via ts-rs)
│ └── lib/ # Typed API client + SSE + i18n (fr/en/es) + TTS/STT engines
├── desktop/ # Tauri desktop app (backend embedded, no Docker needed)
├── ai/ # AI context (for agents working on Kronn itself)
├── templates/ # AI context templates (for managed projects)
├── tests/bats/ # 192 shell tests (bats-core)
├── docker-compose.yml # 3 services: backend, frontend, gateway
└── LICENSE # AGPL-3.0
Stack: Rust (Axum 0.7) + TypeScript (React 19 / Vite) — full type safety end-to-end via ts-rs.
Configuration
Generated at first run in ~/.config/kronn/config.toml:
[server]
host = "127.0.0.1"
port = 3140
[[tokens.keys]]
id = "abc-123"
name = "Personal API Key"
provider = "anthropic"
active = true
[scan]
paths = ["~/projects", "~/work"]
ignore = ["node_modules", ".git", "target"]
scan_depth = 4CI pipeline
GitHub Actions triggered by ci-test label on PRs:
- test-backend:
cargo check+cargo clippy+cargo test(~1090 tests) - test-frontend:
tsc --noEmit+pnpm test(~629 tests, 51 suites) - test-shell:
make test-shell(195 bats tests, 8 suites) - desktop-build:
.github/workflows/desktop-build.yml— builds Tauri installers for Windows, macOS, and Linux
Kronn does not include TLS. Do not expose port 3140 without a TLS reverse proxy (nginx, Caddy, Traefik...).
Authentication is opt-in. Enable Bearer token auth from Settings — Kronn generates a UUID token shown once. Localhost requests always bypass auth. Remote peers (multi-user P2P) require the token.
Kronn is built on a simple principle: every token that doesn't need to be spent, shouldn't be.
AI agents run on physical hardware with a finite lifespan. Every unnecessary inference cycle wears down GPUs and TPUs, accelerates replacements, and adds to the environmental cost of our industry. Kronn's features minimize waste: document codebases so agents don't explore blindly, persist context so it's never rebuilt, frame agents so they get it right the first time.
The long-term vision: de-agentify what doesn't need an agent. MCPs are APIs — when a workflow step is mechanical (post to Slack, create a ticket), a direct API call costs zero tokens. Agent intelligence should be reserved for tasks that actually need reasoning.
Contributions welcome! See CONTRIBUTING.md.
AGPL-3.0 — See LICENSE.