Loki Checkpoint Mode
Makes autonomous coding agents pause for review every N tasks and resume only after your explicit approval, so wrong directions never burn budget.
The opposite design direction from the main skill — a selective-autonomy mode that pauses for approval every N tasks, with explicit guidance on when to use checkpoint mode vs. perpetual mode. A more cautious sub-skill within the same ecosystem.
What does this skill do, and when should you use it?
checkpoint-mode is one of the skills bundled in the Loki Mode repository, implementing "selective autonomy": the agent works in short bursts, then pauses after N tasks or M minutes, generates a summary of accomplishments, next actions, and resources used, and waits for you to approve before resuming. The pattern is drawn from Tim Dettmers' research article on agentic coding. It fits novel projects where the approach may need adjustment, high-cost operations, learning phases, and regulated environments that require an audit trail. It sits between Loki's never-pausing Perpetual mode and its pause-on-every-task Supervised mode. Configuration is entirely via environment variables — no code changes needed.
When LOKI_AUTONOMY_MODE=checkpoint, the orchestrator agent counts completed tasks continuously; when it reaches LOKI_CHECKPOINT_FREQUENCY (10 tasks in the example) or LOKI_CHECKPOINT_TIME (60 minutes in the example), it pauses execution. It generates a Markdown checkpoint summary — completed tasks, next actions, elapsed time, agents used, estimated cost — and writes it to a CHECKPOINT_SUMMARY signal file under .loki/signals/. It then polls for a user-created CHECKPOINT_APPROVED signal file, and on detection clears the signal and resumes work. You can also force pauses after specific phases (e.g. architecture, deployment) via LOKI_CHECKPOINT_PHASES, and effectiveness metrics (task count, approval time, course corrections) are recorded under .loki/metrics/checkpoint-mode/.
- Developers exploring a new domain: the approach is uncertain, so you want the agent to stop every so often for a direction check instead of discovering drift after a full autonomous run.
- Teams running high-cost operations: set a checkpoint before expensive API calls or cloud resource usage so the agent can't keep burning money down a wrong path.
- Engineering teams in regulated environments: the generated summaries and approval signal files form a natural audit trail for compliance.
- Users in a learning phase: use frequent checkpoints as feedback injection points while you calibrate the agent to your intent.
- Owners who require human sign-off at critical phases: mandate pauses after architecture or deployment via LOKI_CHECKPOINT_PHASES.
What are this skill's strengths and limitations?
- Bounds the risk of perpetual autonomy: frequent human feedback catches wrong directions early instead of after a full expensive run.
- Each checkpoint produces a structured summary — tasks done, next actions, cost estimate — so human review is cheap.
- The approval mechanism is plain file-based signaling: transparent, inspectable, and audit-friendly.
- Tunable autonomy across three dimensions (task count, time, mandatory phases) via env vars, forming a spectrum with Perpetual and Supervised modes.
- Tightly coupled to the Loki Mode runtime: relies on LOKI_* env vars, the .loki/signals/ directory convention, and the orchestrator agent type — not portable to other Agent Skills clients as-is.
- Someone must be present to approve or the build hangs waiting; unsuitable for genuinely unattended runs.
- The agent logic in SKILL.md is pseudocode; no standalone automated tests or third-party verification are shown.
- Cost estimates in summaries (e.g. the $0.45 example) are agent-generated and not independently validated.
How do you install this skill?
The skill ships inside the Loki Mode repository at agent-skills/checkpoint-mode/. Installing Loki Mode gives you it: bun install -g loki-mode (npm, Homebrew, and Docker also work). The repository does not document standalone installation of this single skill into other Agent Skills clients; to reuse it independently, evaluate the SKILL.md and its referenced references/production-patterns.md yourself.
How do you use this skill?
Set environment variables before starting a Loki build: export LOKI_AUTONOMY_MODE=checkpoint, optionally LOKI_CHECKPOINT_FREQUENCY=10 (tasks) and LOKI_CHECKPOINT_TIME=60 (minutes), plus LOKI_CHECKPOINT_PHASES="architecture,deployment" for mandatory phase pauses. Then start the build normally (e.g. loki start prd.md). At each checkpoint the agent writes .loki/signals/CHECKPOINT_SUMMARY_<timestamp>.md and pauses; after you review the summary, create an empty .loki/signals/CHECKPOINT_APPROVED file and the agent detects it and resumes.
How does this skill compare with similar options?
Loki Mode itself offers three autonomy levels: Perpetual (never pauses — overnight builds, fully automated CI/CD), Checkpoint (pauses every N tasks — novel projects, new domains), and Supervised (pauses every task — production deployments and critical systems). For direction-uncertain development work, Checkpoint is the sensible middle ground; for clear PRDs and established patterns, Perpetual minimizes interruptions; for critical production systems, Supervised gives the tightest control.