loki-mode
Launch Loki Mode autonomous SDLC agent. Handles PRD-to-deployment with minimal human intervention. Invoke for multi-phase development tasks, bug fixing campaigns, or full product builds.
Best use case
loki-mode is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Launch Loki Mode autonomous SDLC agent. Handles PRD-to-deployment with minimal human intervention. Invoke for multi-phase development tasks, bug fixing campaigns, or full product builds.
Teams using loki-mode should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/openclaw/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How loki-mode Compares
| Feature / Agent | loki-mode | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Launch Loki Mode autonomous SDLC agent. Handles PRD-to-deployment with minimal human intervention. Invoke for multi-phase development tasks, bug fixing campaigns, or full product builds.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Loki Mode - OpenClaw Skill
## When to use
- User asks to "build", "implement", or "develop" a feature from a PRD
- User provides a requirements document and wants autonomous execution
- User says "loki mode" or references autonomous development
- User wants to run a full SDLC cycle on a codebase
## Prerequisites
- `loki` CLI installed on the host (via `npm install -g loki-mode` or Homebrew)
- One of: Claude Code, Codex CLI, or Gemini CLI installed
- Corresponding API key set (ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY)
## How to invoke
### Start a session
Use the bash tool with background mode:
```
bash(command: "loki start <prd-path> --bg --yes --no-dashboard", pty: true, background: true, workdir: "<project-dir>")
```
Key flags:
- `--bg`: Background mode (session outlives the tool call)
- `--yes`: Skip confirmation prompts
- `--no-dashboard`: Avoid port conflicts in sandboxed environments
- `--provider <claude|codex|gemini>`: Select AI provider (default: claude)
- `--budget <amount>`: Set cost limit in USD (auto-pause when exceeded)
### Monitor progress
Poll status every 30 seconds:
```
bash(command: "loki status --json", workdir: "<project-dir>")
```
The JSON output contains:
- `version`: Loki Mode version string
- `status`: inactive, running, paused, stopped, completed, unknown
- `phase`: Current SDLC phase (e.g., BOOTSTRAP, DISCOVERY, ARCHITECTURE, DEVELOPMENT, QA, DEPLOYMENT)
- `iteration`: Current iteration number
- `provider`: Which AI provider is active (claude, codex, gemini)
- `pid`: Process ID of the running session (null if not running)
- `elapsed_time`: Seconds since session start
- `dashboard_url`: URL of the web dashboard (null if disabled)
- `task_counts`: Object with `total`, `completed`, `failed`, `pending` counts
For budget tracking (not in JSON output), read the budget file directly:
```
bash(command: "cat .loki/metrics/budget.json 2>/dev/null || echo '{}'", workdir: "<project-dir>")
```
Budget JSON fields: `budget_limit`, `budget_used`
### Report progress to channel
After each poll, summarize changes:
- Phase transitions ("Moved from ARCHITECTURE to DEVELOPMENT")
- Task completion counts ("12/20 tasks complete, 0 failed")
- Elapsed time ("Running for 45 minutes")
- Error states that need attention (failed tasks > 0, status is unknown)
If budget tracking is active, include cost in updates:
- "Estimated cost: $4.50 / $50.00 budget"
### Control commands
- Pause: `bash(command: "loki pause", workdir: "<project-dir>")`
- Resume: `bash(command: "loki resume", workdir: "<project-dir>")`
- Stop: `bash(command: "loki stop", workdir: "<project-dir>")`
- Status: `bash(command: "loki status", workdir: "<project-dir>")`
- Logs: `bash(command: "loki logs --tail 50", workdir: "<project-dir>")`
### Session complete
When status becomes "stopped" or "completed":
1. Run `loki status --json` for final summary
2. Run `git log --oneline -20` to show commits made
3. Report final task counts, elapsed time, and duration
4. If council verdict exists, include it: `cat .loki/council/report.md`
## Critical rules
- ALWAYS use --bg flag (session must outlive the tool call)
- ALWAYS use --yes flag (no confirmation prompts in non-interactive channels)
- NEVER run loki in the OpenClaw workspace directory itself
- Poll status rather than watching stdout (background mode detaches)
- If session crashes, check `loki logs` before restarting
- Respect budget limits -- include cost in every progress update when tracking is active
- The --no-dashboard flag is recommended to avoid port conflicts in sandboxed environmentsRelated Skills
checkpoint-mode
Pause for review every N tasks - selective autonomy pattern
prompt-optimization
Applies prompt repetition to improve accuracy for non-reasoning LLMs
modern-javascript-patterns
Comprehensive guide for mastering modern JavaScript (ES6+) features, functional programming patterns, and best practices for writing clean, maintainable, and performant code.
framework-migration-legacy-modernize
Orchestrate a comprehensive legacy system modernization using the strangler fig pattern, enabling gradual replacement of outdated components while maintaining continuous business operations through ex
MCP Engineering — Complete Model Context Protocol System
Build, integrate, secure, and scale MCP servers and clients. From first server to production multi-tool architecture.
Legacy System Modernization Engine
Complete methodology for assessing, planning, and executing legacy system modernization — from monolith decomposition to cloud migration. Works for any tech stack, any scale.
ml-model-eval-benchmark
Compare model candidates using weighted metrics and deterministic ranking outputs. Use for benchmark leaderboards and model promotion decisions.
threat-modeling-expert
Expert in threat modeling methodologies, security architecture review, and risk assessment. Masters STRIDE, PASTA, attack trees, and security requirement extraction. Use PROACTIVELY for security architecture reviews, threat identification, or building secure-by-design systems.
statsmodels
Statsmodels is Python's premier library for statistical modeling, providing tools for estimation, inference, and diagnostics across a wide range of statistical methods.
startup-financial-modeling
Build comprehensive 3-5 year financial models with revenue projections, cost structures, cash flow analysis, and scenario planning for early-stage startups.
react-modernization
Master React version upgrades, class to hooks migration, concurrent features adoption, and codemods for automated transformation.
pydantic-models-py
Create Pydantic models following the multi-model pattern for clean API contracts.