How do I install asklokesh-loki-mode-2?

Run these in Claude Code: /plugin marketplace add asklokesh/loki-mode then /plugin install loki-mode@loki-mode. Then prompt normally.

Does asklokesh-loki-mode-2 auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Is asklokesh-loki-mode-2 free?

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

Plugin

asklokesh-loki-mode-2

Multi-agent autonomous SDLC framework. Spec to deployed app. PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. 5 AI providers, 8 quality gates.

Boost this plugin

asklokesh@asklokesh

GitHub

Plugin Signal76/100Solid

maintained98

capable41

documented100

adopted64

Install on Claude Code

> /plugin marketplace add asklokesh/loki-mode
> /plugin install loki-mode@loki-mode

Stats

Python TypeScript Node HTML Bash

+7 tags

Docker Git GitHub Anthropic OpenAI MCP Bun

1,067

Stars

206

Forks

Active

Maintenance

Shell

Language

8h ago

Last commit

8mo ago

Created

Repo: asklokesh/loki-mode

In this plugin

3 commands 2 MCP 1 skill

See everything inside

What's inside

Loki Mode

The spec-driven autonomous builder with verified completion.

The free, source-available autonomous coding agent by Autonomi. Same Loki CLI, SDK, and MCP for everyone; the commercial editions for teams and enterprises are sold under the Autonomi brand (Autonomi Cloud, Autonomi Enterprise).

Hand it a spec. It does not accept "done" on an empty diff or failing tests.

Website | Documentation | Installation | Changelog

Install

bun install -g loki-mode          # recommended (npm, Homebrew, Docker below)

Method	Command	Notes
Bun (recommended)	`bun install -g loki-mode`	Fastest startup for CLI commands.
npm	`npm install -g loki-mode`	Works without Bun (bash fallback). Migrate any time with `loki self-update --to bun`.
Homebrew	`brew tap asklokesh/tap && brew install loki-mode`	Auto-installs Bun as a dep.
Docker	`docker pull asklokesh/loki-mode:latest`	Bun + Claude CLI pre-installed. See DOCKER_README.md.

Upgrade with loki self-update. Long form: Installation Guide.

claude plugin marketplace add asklokesh/loki-mode
claude plugin install loki-mode@loki-mode

Adds three slash commands and the Loki MCP server (memory, task queue, code search, build management) to Claude Code. It calls the CLI rather than bundling it, so install loki-mode above first. Verify with claude plugin list: a healthy install reports Status: enabled.

Use it

loki quickstart                   # guided first build: asks a few questions, quotes cost, builds

That is the whole happy path. It asks for a one-line idea, picks a template, shows the real cost and time estimate before spending anything, then builds. Press Enter through every step and you get a sample Todo app.

One command, no prompts (CI, scripts, containers, any shell without a terminal):

loki quickstart "a todo app with user accounts" --yes

Both halves are required with no terminal: an idea (or a path to a PRD file) and an explicit --yes. Given both, Loki picks the top-ranked template automatically, prints the same honest cost and time estimate, and starts the build without asking anything. Missing either half exits 2 with the needs-a-terminal message and writes nothing, so an ambient LOKI_AUTO_CONFIRM or a stray argument in CI can never start a paid build on its own. Existing files are never overwritten: if prd.md is present the PRD lands at prd-quickstart.md, then numbered suffixes as needed.

Choose an exact shipped starter when the top-ranked match is not the one you want:

loki quickstart --list-templates
loki quickstart --list-templates --json       # schema-v1 automation output
loki quickstart "an internal reporting workspace" --template dashboard --yes

Template discovery works without a terminal or provider and lists every shipped starter's stable name and purpose in catalog order. It returns before estimation, consent, PRD writes, or build execution. Positional input and execution/preview flags are intentionally incompatible; --json is the only optional modifier.

--template accepts an exact template name for idea inputs and works the same way with interactive use or --dry-run (including JSON preview). Unknown templates, duplicate flags, and combinations with a PRD path refuse before provider discovery, estimation, writes, or build execution.

Preview the same deterministic template choice and estimator-backed plan with zero writes or execution:

loki quickstart "a todo app with user accounts" --dry-run

Preview requires an idea or readable PRD path, works without a terminal or AI provider, and exits before creating a PRD or starting a build. --dry-run and --yes are mutually exclusive so execution intent is never ambiguous.

For scripts and local dashboards, add --json to receive one versioned JSON object instead of terminal text:

loki quickstart "a todo app with user accounts" --dry-run --json > preview.json
loki quickstart --verify-preview preview.json --json
loki quickstart --from-preview preview.json --yes

The object contains the input kind, deterministic selected template (or null for an existing PRD), the exact estimator response under plan, and a bounded continuation containing the exact idea/template or the PRD path and SHA-256. --verify-preview validates the same bounded duplicate-key-rejecting schema and requires either a currently shipped idea template or the unchanged digest-bound PRD, while emitting no idea or PRD path. It accepts a file or piped stdin and returns before provider discovery, estimation, writes, or build execution. --from-preview requires explicit argv --yes, rejects malformed, conflicting, symlinked, or changed inputs before provider and build boundaries, then uses the existing no-clobber quickstart path. The saved plan is evidence rather than execution authority: Loki recomputes and displays the current estimate before starting. --json requires --dry-run; invalid input or estimator failure writes no JSON, and preview still exits before provider discovery, file writes, or build execution.

Or go straight at it:

loki quick "build a landing page with a signup form"     # one-shot task
loki start prd.md                                        # build from a spec you wrote
loki modernize heal ./your-repo --assess                 # existing codebase, read-only

Loki needs a model to drive. An ANTHROPIC_API_KEY alone is enough (the Claude Agent SDK ships inside Loki); or point it at Claude Code, aider, cline, or an open model. Run loki doctor and it tells you exactly what is missing.

export ANTHROPIC_API_KEY=sk-...
loki doctor                       # checks your setup, names any blocker

Try it first, without installing

npx loki-mode tour                # no install, no API key, no spend, no network

Prints a real Evidence Receipt from a past build, headline and all:

Headline: VERIFIED WITH GAPS

| Fact          | Value                                    |
| Files changed | 8                                        |
| Diff sha256   | c2be6fff3e774c387f276277b25fc424f07b667… |
| Tests         | verified (node-test)                     |
| Build         | not_run                                  |
| Security      | findings                                 |
| Cost          | $10.3218                                 |

"WITH GAPS" is the point. Build was not run, security has findings, and the receipt says so on its own front page. Recompute the diff hash yourself and check it matches -- you are not asked to trust the agent's self-report.

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()), selects reviewers from a specialist pool (agents/types.json ships 41 role definitions; 10 are keyword-scored by the review selector at run.sh:FOCUS_KEYWORDS, alongside the mandatory reviewers, and the rest are role descriptions in references/agents.md that the orchestrator adopts per phase rather than separate processes), with parallel review (blind council) and optional worktree streams on Claude Code, sequential on other providers - and runs autonomous RARV cycles (Reason - Act - Reflect - Verify, see run.sh:run_autonomous()) with 8 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.

Self-reported completion is the failure users actually hit. A survey of the open issue trackers of seven coding harnesses (OpenHands, Cline, Aider, SWE-agent, Roo-Code, OpenCode, Continue) found the recurring complaint is the agent silently not doing the work -- "always stuck at Preparing write" (opencode#11112, 76 comments), "Continue not making changes to code" (continue#7143), "Agent does not execute functions" (continue#5696). None of those seven publishes a machine-checkable completion artifact.

We measured every named competitor that ships a local CLI -- opencode 1.18.9, aider 0.86.2, codex-cli 0.146.0, Claude Code 2.1.220, cursor-agent -- and none exposes a command that verifies the agent's own output. Rerun it yourself with bash tests/test-competitor-verify-surface.sh.

That is a measurement of the CLI surface, not of whole products: a web UI or an API could expose something --help does not, and Devin and Replit Agent ship no local CLI so they are not covered.

Evaluating this against something else? docs/EVALUATING.md puts a runnable command next to every claim we make, and states plainly what we do not have (no enterprise case studies, no independent benchmark placement, and generation is not air-gapped). It ends with the one question worth asking any agent vendor, including us.

Already have a codebase? Start read-only.

Most agents are built to create new apps. The harder, more valuable problem is the ten-year-old repo that pays the bills. Loki works on both, and on an existing codebase it starts by changing nothing:

loki modernize heal ./your-repo --assess          # read-only. no writes, no commits.
loki modernize heal ./your-repo --assess --json   # same, machine-readable

You get a modernization readiness report: language mix, a 4-level maturity rating, technical-debt signals (test coverage, TODO density, oversized files, dependency staleness), and a ranked list of where to start -- ordered by blast radius, so the first change is the one least likely to break something.

Then, if you want it to act:

loki modernize heal ./your-repo --strict          # block ALL behavioral change without approval
loki modernize heal ./your-repo --phase archaeology   # extract knowledge only
loki modernize heal ./your-repo --compliance healthcare   # or fintech | government

The healing pipeline runs in phases -- archaeology, stabilize, isolate, modernize, validate -- and the validate phase checks behavioral equivalence against the pre-change baseline, not just that the tests are green. Friction points (the weird code that exists for a reason nobody remembers) are cataloged before anything touches them, because in a legacy system the strange code is usually load-bearing.

The Evidence Receipt: don't trust the agent, check it

Every coding agent tells you it finished. Loki hands you something you can check yourself.

We are not the only tool that checks its own work, and you should be suspicious of anyone who claims to be. Lovable runs a security scan on every

File tree

Showing a partial view of a very large repo.

More plugins by @asklokesh.

View @asklokesh’s profile

VerifiedPlugin

Development Python TypeScript