How it works: Drop a spec -- a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. Loki Mode classifies complexity (run.sh:detect_complexity()), assembles an agent team from 41 specialized types across 8 swarms, and runs autonomous RARV cycles (Reason - Act - Reflect - Verify, see run.sh:run_autonomous()) with 11 quality gates (see skills/quality-gates.md). Code is not "done" until it passes automated verification. Output is a Git repo with source, tests, configs, and audit logs.

Why Loki Mode?

• Spec to product, autonomously -- Describe what you want, walk away, come back to working code with tests. Loki runs the full RARV-C closure loop (Reason - Act - Reflect - Verify - Close) until the work is actually done, not just attempted.
• Production quality built in -- 11 quality gates (skills/quality-gates.md), blind 3-reviewer code review (run.sh:run_code_review()), anti-sycophancy checks
• Cross-project memory -- Episodic/semantic/procedural memory with vector search; knowledge learned on one project surfaces on the next (v5.15.0+, see memory/engine.py)
• Self-hosted and private -- Your keys, your infrastructure, no data leaves your network
• Legacy system healing -- loki heal archaeology/stabilize/isolate/modernize/validate phases (v6.67.0, see skills/healing.md)
• MCP server -- 15 tools including ChromaDB code search (mcp/server.py)
• Full-stack output -- Source code, tests, Docker configs, CI/CD pipelines, audit logs
• Provider-agnostic -- runs on Claude, Codex, Cline, or Aider with automatic failover (loki-ts/src/runner/providers.ts); no vendor lock-in. Gemini CLI deprecated v7.5.18; Antigravity CLI coming soon.
• Open source -- Free for personal, internal, and academic use.

Get Started in 30 Seconds

Prerequisites

Loki drives a coding agent CLI and orchestrates real builds, so it needs a few tools on your PATH. loki doctor checks all of these and tells you what is missing.

Required:

• An agent provider CLI (at least one): Claude Code (claude, Tier 1, recommended), or OpenAI Codex CLI (codex), Cline, or Aider.
• Python 3.10+ (python3) for the dashboard, memory system, and orchestration helpers.
• Git 2.x (git) for checkpoints and worktrees.
• curl for installation and network calls.

Recommended:

• Bun 1.3.0+ (bun) for the fast runtime (the recommended install path below installs it).
• Node.js 18+ and npm if you install via npm instead of Bun.
• jq for nicer JSON handling in shell flows.
• Docker if you want Loki's App Runner to run containerized projects, or to run Loki itself from the published image.

You also need credentials for whichever provider you use (for Claude Code, an authenticated claude login or ANTHROPIC_API_KEY).

Recommended (Bun, fastest):

# Install Bun once (skip if you already have it)
curl -fsSL https://bun.sh/install | bash      # macOS / Linux
# or: brew install oven-sh/bun/bun

bun install -g loki-mode
loki doctor                                   # verify environment
loki init my-app --template simple-todo-app
cd my-app
loki start prd.md                             # autonomous build from a Markdown PRD
loki start owner/repo#123                     # ...or a GitHub issue
loki start ./openapi.yaml                     # ...or an OpenAPI/YAML spec

Or skip scaffolding and go straight to a quick task:

loki quick "build a landing page with a signup form"

Other install methods (all work, all keep working):

Upgrading:

loki self-update                  # upgrade in place via current manager
loki self-update --to bun         # switch from npm/brew to Bun
loki self-update --check          # show current install path + manager

loki self-update auto-detects which package manager installed loki and runs the right upgrade. If you installed via npm and want to switch to Bun (recommended for v8.0.0 forward-compat), loki self-update --to bun does the migration in one command (installs via Bun first, then uninstalls the npm copy).

See the Installation Guide for the long form.

Runtime Architecture

Loki Mode is in a phased migration from a Bash-based runtime to a TypeScript/Bun runtime. The migration has merged to main and ships incrementally with each release.

What ships today:

• Commands routed to the Bun runtime when bun is on PATH (the router lives in bin/loki): version, --version, -v, status, stats, doctor, provider (covers provider show and provider list), memory (covers memory list and memory index), rollback, kpis, and internal.
• Every other command continues to execute on the existing Bash CLI (autonomy/loki), including the autonomous loki start / loki run loop which remains the Bash orchestrator (autonomy/run.sh).
• If bun is not on PATH, the shim falls through to Bash silently. Existing users without Bun installed see no behavior change.

Rollback flag:

Force every command to take the legacy Bash path:

LOKI_LEGACY_BASH=1 loki <cmd>

This is the documented escape hatch for any user who hits a regression on the Bun route. The Bash path remains the source of truth through Phase 5.

Phase 6 (planned, calendar TBD):

The next major release sunsets the Bash runtime entirely. There is no firm calendar date. Users who need to stay on the Bash route should pin the last v7.x release.

Cost:

• Adds a Bun runtime dependency (Bun 1.3.0 or newer recommended; the shim works as long as bun resolves).
• Adds a Bun toolchain to the system (Bun itself is roughly 50 MB installed via brew install or the official curl installer). The published loki-ts/dist/loki.js bundle inside the npm tarball is approximately 152 KB.
• Speedup on the ported commands is measured in .loki/metrics/migration_bench_soak.jsonl and analysed in ADR-001. Recorded soak results show roughly 3x to 5x faster execution on the ported commands (per-command range 2.9x to 5.0x); treat as indicative, not contractual.

More:

• UPGRADING.md -- per-version upgrade and rollback guidance.
• ADR-001: Runtime Migration -- design rationale and phase definitions.

What You Can Build

What To Expect

Architecture

Purple Lab

The hosted development platform. A Replit-like web UI for visual PRD-to-code workflow with AI chat for iterative development.

loki web                           # launches at http://localhost:57375

Loki Mode vs. Alternatives

Loki Mode is the only platform that is fully self-hosted, open source, and includes automated quality verification. Your code, your keys, your infrastructure.

Provider-Agnostic Runtime

Loki's autonomy and quality loop are the product; the underlying coding CLI is swappable. Loki runs on any of the providers below so you are never locked to one vendor.

Claude gets full features (subagents, parallelization, MCP, Task tool). Other active providers run sequentially. Auto-failover switches providers when rate-limited. See Provider Guide.

CLI Reference

Run loki --help for all options. Full reference: CLI Reference | Config: config.example.yaml

loki start --bmad-project ./my-project

export LOKI_TLS_ENABLED=true
export LOKI_OIDC_PROVIDER=google
export LOKI_AUDIT_ENABLED=true
loki enterprise status

Limitations

What "autonomous" means: The system runs RARV cycles without prompting. It does NOT access your cloud accounts, payment systems, or external services unless you provide credentials. Human oversight is expected for deployment, API keys, and critical decisions.

Research Foundation

Contributing

git clone https://github.com/asklokesh/loki-mode.git && cd loki-mode
npm install && npm test              # 683 tests
python3 -m pytest                    # 631 tests

See CONTRIBUTING.md for guidelines.

License

Business Source License 1.1 -- Free for personal, internal, academic, and non-commercial use. Converts to Apache 2.0 on March 19, 2030. Contact founder@autonomi.dev for commercial licensing.