Package Exports

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (loki-mode) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Loki Mode

Autonomous multi-agent development with self-verification

PRD in, tested code out.

Website | Documentation | Installation | Changelog | Purple Lab Web UI

How it works: You provide a PRD. Loki Mode classifies complexity, assembles an agent team from 41 specialized types across 8 swarms, and runs autonomous RARV cycles (Reason - Act - Reflect - Verify) with 9 quality gates. Code is not "done" until it passes automated verification. Output is a Git repo with source, tests, configs, and audit logs.

Get Started in 30 Seconds

npm install -g loki-mode
loki doctor                        # verify environment
loki start ./prd.md                # autonomous build starts

Other install methods

Method	Command
Homebrew	`brew tap asklokesh/tap && brew install loki-mode`
Docker	`docker pull asklokesh/loki-mode`
Inside Claude Code	`claude --dangerously-skip-permissions` then type "Loki Mode"
Git clone	`git clone https://github.com/asklokesh/loki-mode.git`

See the full Installation Guide.

What To Expect

	Simple	Standard	Complex
Examples	Landing page, todo app, single API	CRUD + auth, REST API + React	Microservices, real-time, ML pipelines
Duration	5-30 min	30-90 min	2+ hours
Autonomy	Completes independently	May need guidance on complex parts	Use as accelerator with human review

Architecture

RARV Cycle

Every iteration: Reason (read state) - Act (execute, commit) - Reflect (update context) - Verify (run tests, check spec). Failures trigger self-correction.

Core Workflow

41 Agent Types

8 swarms: engineering, operations, business, data, product, growth, review, orchestration. Auto-composed by PRD complexity.

Agent Types

9 Quality Gates

Blind review, anti-sycophancy, severity blocking, mock/mutation detection. Code does not ship until all gates pass.

Quality Gates

Memory System

3-tier architecture: episodic (interaction traces), semantic (generalized patterns), procedural (learned skills). Vector search optional.

Memory Architecture

Dashboard

Real-time monitoring, agent status, task queue, WebSocket streaming. Auto-starts at localhost:57374.

Dashboard Guide

Enterprise Layer

TLS, OIDC/SSO, RBAC, OTEL tracing, policy engine, audit trails. Activated via env vars.

Enterprise Guide

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

Platform Pages

Home -- PRD input with plan-before-build flow
Projects -- browse, search, filter past builds
Templates -- 20+ starter PRDs by category
Settings -- provider selection, configuration

IDE Workspace

Monaco editor with tabs, Cmd+P quick open
AI chat panel for iterative development
Activity panel: build log, agents, quality gates
Live preview with URL bar navigation
Right-click context menu: Review, Test, Explain

Multi-Provider Support

Provider	Autonomous Flag	Parallel Agents	Install
Claude Code	`--dangerously-skip-permissions`	Yes (10+)	`npm i -g @anthropic-ai/claude-code`
Codex CLI	`--full-auto`	Sequential	`npm i -g @openai/codex`
Gemini CLI	`--approval-mode=yolo`	Sequential	`npm i -g @google/gemini-cli`
Cline CLI	`--auto-approve`	Sequential	`npm i -g @anthropic-ai/cline`
Aider	`--yes-always`	Sequential	`pip install aider-chat`

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

CLI Reference

All commands

Command	Description
`loki start [PRD]`	Start with optional PRD file
`loki stop`	Stop execution
`loki pause` / `resume`	Pause/resume after current session
`loki status`	Show current status
`loki dashboard`	Open web dashboard
`loki web`	Launch Purple Lab web UI
`loki doctor`	Check environment and dependencies
`loki plan [PRD]`	Pre-execution analysis: complexity, cost, iterations
`loki review [--staged\|--diff]`	AI-powered code review with severity filtering
`loki test [--file\|--dir\|--changed]`	AI test generation (8 languages, 9 frameworks)
`loki onboard [path]`	Project analysis and CLAUDE.md generation
`loki import`	Import GitHub issues as tasks
`loki ci`	CI/CD quality gate integration
`loki failover`	Cross-provider auto-failover management
`loki memory <cmd>`	Memory system: index, timeline, search, consolidate
`loki enterprise`	Enterprise feature management
`loki version`	Show version

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

BMAD Method Integration

Loki Mode integrates with the BMAD Method, a structured AI-driven agile methodology. If your project uses BMAD for requirements elicitation, Loki Mode can consume those artifacts directly:

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

The adapter handles BMAD's frontmatter conventions, FR-format functional requirements, Given/When/Then acceptance criteria, and artifact chain validation. Non-BMAD projects are unaffected -- the integration is opt-in via --bmad-project.

See BMAD Integration Validation.

Enterprise Features

Enterprise features are included but require env var activation. Self-audit: 35/45 capabilities working, 0 broken, 1,314 tests passing.

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

Benchmarks

Self-reported results from the included test harness. Verification scripts included for reproduction.

Benchmark	Result	Notes
HumanEval	162/164 (98.78%)	Max 3 retries, RARV self-verification
SWE-bench	299/300 patches	Patch generation -- evaluator not yet run

See benchmarks/ for methodology.

Presentation

Loki Mode Presentation

9 slides: Problem, Solution, 41 Agents, RARV Cycle, Benchmarks, Multi-Provider, Full Lifecycle

Download PPTX

Limitations

Area	What Works	What Doesn't (Yet)
Code Gen	Full-stack apps from PRDs	Complex domain logic may need human review
Deploy	Generates configs, Dockerfiles, CI/CD	Does not deploy -- human runs deploy commands
Testing	9 automated quality gates	Test quality depends on AI assertions
Providers	5 providers with auto-failover	Non-Claude providers lack parallel agents
Dashboard	Real-time single-machine monitoring	No multi-node clustering

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

Papers and sources

Source	What We Use
Anthropic: Building Effective Agents	Evaluator-optimizer, parallelization
Anthropic: Constitutional AI	Self-critique against quality principles
DeepMind: Scalable Oversight via Debate	Debate-based verification in council review
DeepMind: SIMA 2	Self-improvement loop design
OpenAI: Agents SDK	Guardrails, tripwires, tracing
NVIDIA ToolOrchestra	Efficiency metrics, reward signals
CONSENSAGENT (ACL 2025)	Anti-sycophancy in blind review
GoalAct	Hierarchical planning for complex PRDs

Practitioner insights: Boris Cherny, Simon Willison, HN Community

Full Acknowledgements -- 50+ papers and resources

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.

Autonomi | Documentation | Changelog | Comparisons