loki-mode
Version 2.35.0 | PRD to Production | Zero Human Intervention > Research-enhanced: OpenAI SDK, DeepMind, Anthropic, AWS Bedrock, Agent SDK, HN Production (2025)
Profile →npx skills add sickn33/agentic-awesome-skills --skill loki-mode --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Loki Mode enables autonomous execution of DevOps tasks without human input. It prescribes a sequence of memory checks, state review, and queue inspection each turn, then follows a RARV cycle (Reason-Act-Reflect-Verify) to dispatch subagents, write/verify code, and update memories. It defines a hierarchy of task models (Opus for planning, Sonnet for development, Haiku for operations) and a routing mode that chooses Direct Routing for simple tasks or Supervisor Mode for complex ones. It includes a comprehensive set of patterns and safeguards (guardrails, tripwires, deterministic validation, memory consolidation) and specifies how to measure efficiency (wall time, agent count, retry count, model usage) and reward signals. It also enforces strict prerequisites and protected files while running. Key operational tools and files are referenced (e.g., OpenAI SDK, Playwright MCP, CONTINUITY.md, etc.).
How it works
- On each turn, it reads .loki/CONTINUITY.md, retrieves memories from memory directories, checks .loki/state/orchestrator.json, reviews .loki/queue/pending.json, and then follows the RARV cycle. It executes tasks by dispatching subagents via the Task tool, runs tests, commits changes, and updates memories and logs. It employs a memory consolidation process (episodic to semantic) after task completion. It selects subagents using a model strategy (Opus for planning, Sonnet for development, Haiku for operations) and can run multiple Haiku agents in parallel for unit tests. It validates outputs with automated tests and against the OpenAPI spec file. It supports direct routing for simple tasks and supervisor mode for complex tasks, with a fallback to supervisor if intent is unclear. It provides E2E testing guidance via Playwright MCP and enforces a one-feature-at-a-time principle.
When to use it
- Use when you require autonomous, end-to-end task execution in DevOps & Cloud domains, with no human intervention and a need for structured planning, development, and operations workflows. It should be applied when the task complexity warrants either direct routing (simple, single-domain tasks) or supervisor orchestration (complex, multi-step tasks).
What it can touch
- Tools and models declared for operation include claude-code, codex, and cursor. It dispatches subagents through a Task tool and can run automated tests, browser automation (Playwright MCP), and API/architecture validation against an OpenAPI spec located at
.loki/specs/openapi.yaml.
Caveats
- Declared risk is critical. The system mandates zero human intervention and includes numerous guardrails and failure-handling pathways. It requires strict adherence to the RARV cycle and prohibits editing certain running files. It relies on multiple external SDKs and patterns from third-party providers and has defined protection for running autonomy scripts. The license is MIT. The skill is part of a larger repository with 1101 files in the skill folder and 1945 skills published from the same repo.
# Loki Mode - Multi-Agent Autonomous Startup System > **Version 2.35.0** | PRD to Production | Zero Human Intervention > Research-enhanced: OpenAI SDK, DeepMind, Anthropic, AWS Bedrock, Agent SDK, HN Production (2025) --- ## Quick Reference ### Critical First Steps (Every Turn) 1. **READ** `.loki/CONTINUITY.md` - Your working memory + "Mistakes & Learnings" 2. **RETRIEVE** Relevant memories from `.loki/memory/` (episodic patterns, anti-patterns) 3. **CHECK** `.loki/state/orchestrator.json` - Current phase/metrics 4. **REVIEW** `.loki/queue/pending.json` - Next tasks 5. **FOLLOW** RARV cycle: REASON, ACT, REFLECT, **VERIFY** (test your work!) 6. **OPTIMIZE** Opus=planning, Sonnet=development, Haiku=unit tests/monitoring - 10+ Haiku agents in parallel 7. **TRACK** Efficiency metrics: tokens, time, agent count per task 8. **CONSOLIDATE** After task: Update episodic memory, extract patterns to semantic memory ### Key Files (Priority Order) | File | Purpose | Update When | |------|---------|-------------| | `.loki/CONTINUITY.md` | Working memory - what am I doing NOW? | Every turn | | `.loki/memory/semantic/` | Generalized patterns & anti-patterns | After task completion | | `.loki/memo
- Quick Reference
- Critical First Steps (Every Turn)
- Key Files (Priority Order)
- Decision Tree: What To Do Next?
- SDLC Phase Flow
- Essential Patterns
- Prerequisites
- Core Autonomy Rules
- Protected Files (Do Not Edit While Running)
- RARV Cycle (Every Iteration)
- Model Selection Strategy
- Task Tool Model Parameter
- Opus Task Categories (RESTRICTED - Planning Only)
- Sonnet Task Categories (Development)
Launch with autonomous permissions claude
What does the loki-mode skill do?
Version 2.35.0 | PRD to Production | Zero Human Intervention > Research-enhanced: OpenAI SDK, DeepMind, Anthropic, AWS Bedrock, Agent SDK, HN Production (2025)
How do I install it?
Run `npx skills add sickn33/agentic-awesome-skills --skill loki-mode --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From sickn33/agentic-awesome-skills, a repository with 44,414 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.