What is the Reason-Act-Reflect-Verify (RARV) cycle in Loki Mode?

The RARV cycle is Loki Mode's core loop: reason by reading `.loki/CONTINUITY.md` and its "Mistakes & Learnings" before acting, act by dispatching a subagent or executing directly with atomic commits, reflect by updating CONTINUITY.md and checking completion promises, and verify by running automated tests, checking the build, and validating against the OpenAPI spec—failed verification rolls back to the last git checkpoint and retries with the learning recorded.

How does Loki Mode assign AI models to different tasks?

Model selection is tiered by task type: Opus 4.5 handles planning, architecture, and security-audit decisions; Sonnet 4.5 manages implementation and functional/integration/E2E testing; and Haiku 4.5 is preferred for unit tests, docs, linting, bash operations, and monitoring—agents are dispatched in parallel where independent and can be resumed via an `agent_id` after interruptions.

What quality gates must code pass before shipping?

Code must pass input guardrails for scope and injection, static analysis, a blind three-reviewer system with an anti-sycophancy Devil's Advocate pass on unanimous approval, output guardrails checking spec compliance and secrets, severity-based blocking where Critical/High/Medium issues block and Low/Cosmetic become TODOs, and test-coverage gates requiring 100% pass rate and over 80% unit coverage—features are additionally verified end-to-end with Playwright MCP browser automation.

What happens if Loki Mode encounters an unrecoverable failure?

On an unrecoverable failure, Loki Mode saves state, halts, and requests a human rather than retrying blindly—it does not attempt to recover automatically.

How many specialized agent types does Loki Mode have and how are they organized?

Loki Mode draws on 37 specialized agent types organized across seven swarms: Engineering (frontend, backend, database, mobile, API, QA, performance, infra), Operations (devops, SRE, security, monitoring, incident, release, cost, compliance), Business (marketing, sales, finance, legal, support, HR, investor, partnerships), Data (ML, data engineering, analytics), Product (PM, design, technical writing), Growth (growth-hacker, community, success, lifecycle), and Review (code, business, security)—spawning only the agents a given project actually needs.

Skill

Automate PRD to Production with Zero Human Intervention

Name: Loki Mode - Multi-Agent Autonomous Startup System
Availability: OnlineOnly
Author: Antigravity

Loki Mode drives a Claude Code project from PRD to production with zero human intervention via a RARV cycle and 37 specialized subagents.

Get skill

Works with openaideepmindanthropicaws github

Antigravity

Own this? Claim it

Spark score

out of 100

Updated 5 days ago

Source checked Sep 16, 2026

Version 17.3.0

Add to Favorites

Why it matters

This system autonomously manages the entire software development lifecycle, from understanding product requirements to deploying and monitoring in production, with absolutely no human oversight required.

Outcomes

What it gets done

Automate PRD analysis and task generation.

Generate code, unit tests, and monitoring agents.

Perform autonomous code reviews and self-verification.

Manage CI/CD pipelines and production deployment.

Install

Add it to your toolbox

Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-loki-mode | bash

After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.

Reports

Agent outcome reports

No reports yet

Overview

Loki Mode - Multi-Agent Autonomous Startup System

Loki Mode is an autonomous multi-agent workflow for Claude Code that drives a project from PRD to production with zero human intervention, using a Reason-Act-Reflect-Verify cycle, strict Opus/Sonnet/Haiku model routing, 37 agent types across 7 swarms, and blind-review quality gates before every ship. Invoke it with the trigger "Loki Mode" when a project should run its full SDLC autonomously without stopping for approval - skip it for a single small task or when the plan needs human review first.

What it does

Defines "Loki Mode," an autonomous multi-agent orchestration workflow for Claude Code that drives a project from PRD to production with zero human intervention. Every turn follows a four-step RARV cycle: Reason (read .loki/CONTINUITY.md working memory and the pending task queue), Act (dispatch a subagent or execute directly, then commit atomically), Reflect (update CONTINUITY.md and check the completion promise), and Verify (run automated tests and check against .loki/specs/openapi.yaml, rolling back to the last git checkpoint and retrying on failure). Model selection is strict: Opus is reserved for planning and architecture only, Sonnet handles feature implementation and functional or integration testing, and Haiku runs unit tests, docs, linting, and monitoring, with 10+ Haiku agents dispatched in parallel for a test suite. A routing layer picks Direct dispatch, skipping orchestration, for single-domain tasks versus full Supervisor Mode for multi-step ones. The orchestrator can spawn from 37 specialized agent types across 7 swarms - Engineering, Operations, Business, Data, Product, Growth, Review - as a project needs them, and every ship goes through quality gates: input guardrails, static analysis, a three-reviewer blind review run in parallel (always Opus, never Sonnet), a Devil's Advocate pass triggered by unanimous approval, output guardrails, and severity-based blocking where Critical/High/Medium issues block and Low/Cosmetic issues become TODO comments.

# Launch with autonomous permissions
claude

When to use - and when NOT to

Invoke it with the literal trigger "Loki Mode" or "Loki Mode with PRD at [path]" when a project should run autonomously through its full SDLC - Bootstrap, Discovery, Architecture, Infrastructure, Development, QA, Deployment, Business Ops, Growth Loop - without stopping to ask questions. Its own "Skip When" guidance says not to use it when human approval is needed, when the plan should be reviewed first, or for a single small task. Hard constraints bound its autonomy even while running: no third-party dependencies without approval, maintain backwards compatibility with the v1.x API, keep response time under 200ms, and certain files (the running script itself, .loki/dashboard/*) must never be edited mid-run since that crashes the session - fixes get logged to CONTINUITY.md's "Pending Fixes" instead. Human escalation still triggers automatically on a retry count over 3, a domain of payments, auth, or PII, a confidence score under 0.6, wall time exceeding 3x expected, or token budget exceeding 80% used.

Inputs and outputs

Input is an optional PRD path plus an existing .loki/ state directory, or a fresh bootstrap; output is a running, versioned project plus a persistent state tree: CONTINUITY.md (working memory, updated every turn), specs/openapi.yaml (the spec-first source of truth), queue/{pending,in-progress,completed,dead-letter}.json, state/orchestrator.json and per-agent state, memory/{episodic,semantic,skills,ledgers,handoffs}/, and metrics/{efficiency,rewards}/. Every subagent dispatch is required to carry a structured prompt with GOAL, CONTEXT, OUTPUT FORMAT, and a WHEN-COMPLETE report covering why, what, trade-offs, and risks.

Integrations

Built for the Claude Code Task tool specifically - its model parameter, run_in_background, and agent resume for interrupted work - plus Playwright MCP for mandatory browser-based E2E verification before marking a UI feature complete, and it reads a target project's AGENTS.md (the OpenAI/AAIF standard) ahead of CLAUDE.md and its own CONTINUITY.md in context priority. Patterns are explicitly drawn from and cite OpenAI's Agents SDK (guardrails, tripwires, handoffs), Anthropic (Explore-Plan-Code, Constitutional AI self-critique), DeepMind (hierarchical reasoning, debate verification), AWS Bedrock (routing mode), and NVIDIA ToolOrchestra (efficiency and reward tracking).

Who it's for

Teams or solo operators who want to hand an entire product build - from PRD to a deployed, monitored service - to a self-directing multi-agent Claude Code session with its own memory, quality gates, and escalation rules, rather than supervising each step manually.

FAQ

Common questions

Discussion