AgentLoopKit
A drop-in engineering loop for coding agents.
- Platform
- Node.js 20+, macOS, Linux, Windows
- Pricing
- Free (MIT)
Overview
- Built
- 2026
- Version
- 0.27.0
- Category
- Developer Tools / Agentic engineering
- Distribution
- npm / npx
- CLI
- agentloop, agentloopkit
- License
- MIT
Coding agents move fast and leave reviewers little to go on: unclear scope, missing tests, a summary that says nothing. AgentLoopKit installs a repo-local engineering harness into the codebase your agent is editing, so a session ends with a scoped contract, verification output, and a handoff a reviewer can read. `npx agentloopkit init` writes `AGENTS.md`, `AGENTLOOP.md`, `agentloop.config.json`, and a `.agentloop/` directory of templates, gates, policies, reports, handoffs, and agent instructions.
It is not another agent. It runs inside the repository your agent already edits and holds each session to the same loop: specify the task, constrain risk, make the smallest useful diff, verify with your own commands, then hand off with evidence.
It fits developers who already run coding agents and want each session to leave proof behind, not just a diff. A scoped contract goes in; a verification report and a reviewer-ready handoff come out. It pairs with ProjScan, the studio's code-intelligence tool, though neither one needs the other.
Features
What it does well.
Task contracts
`agentloop create-task` turns a fuzzy request into a scoped Markdown file: problem statement, desired outcome, acceptance criteria, risks, non-goals, assumptions, likely files, and files not to touch. The agent gets a boundary before the first edit instead of guessing at scope mid-session. `task list --json` and `task show --json` hand the same contract to an agent without parsing prose.
Verification reports
`agentloop verify` reads `agentloop.config.json`, runs your configured checks, captures the output, and writes an auditable report under `.agentloop/reports/`. It does not hide failures: each failed command keeps its exit code and the last useful output lines, and long logs keep their first and last lines so the real error stays visible.
Agent instructions
`agentloop install-agent` writes repo-specific guidance for Codex, Claude Code, Cursor, OpenCode, Gemini CLI, GitHub Copilot CLI, or all of them at once. When a third-party config convention is uncertain, AgentLoopKit writes safe repo-local Markdown rather than editing tool config it cannot verify.
Safety policies
`init` generates local Markdown policies for destructive actions, secrets, dependencies, public APIs, database changes, UI changes, and security review. `agentloop policy list`, `show`, and `status` keep them visible from the CLI and flag when a local policy has drifted from the bundled template, so you review it like code.
Status and gates
`agentloop status` shows the active task, next action, dirty files, latest verification, and missing commands. `agentloop check-gates` checks for the evidence reviewers expect, a contract, a verification report, a handoff, harness files, and core policies, and `--strict` fails CI when a warning gate is unmet. Status is not evidence: gates exist so an agent cannot claim completion without it.
Handoffs and evidence
`agentloop handoff` writes a deterministic reviewer summary from git status, diff stats, the active contract, and the latest verification report, grouping changed files into review areas. `report` writes a local static HTML evidence page, `release-notes` drafts notes from local evidence, and `badge` writes an SVG status badge. None of it calls an LLM or a network service.
Local MCP server
`agentloop mcp-server` exposes read-only AgentLoop state, status, next action, task contracts, policies, the latest verification report, and handoffs, to MCP-aware clients over local stdio. It never runs verification commands, edits files, reads `.env`, or uploads repo contents.
See it in action
A closer look.
One loop, from init to handoff
`npx agentloopkit init` writes the harness, then `create-task`, `verify`, `check-gates`, and `handoff` run the loop. Each command writes a local file, calls no LLM, and contacts no server.
Verification you can audit
`agentloop verify` runs your configured checks and writes a dated report under `.agentloop/reports/`. Failed commands keep their exit codes and output, so the evidence reads the same for an agent, a reviewer, or a CI step.
The loop
Specify, verify, hand off.
One workflow runs from a fuzzy request to gated evidence. Each step is a command you hand to the next agent or reviewer.
- Specify the task
- `agentloop create-task --type feature --title "..."` writes a contract with the problem, outcome, acceptance criteria, likely files, forbidden files, verification commands, and rollback notes. Pin it with `task set` when more than one task is open.
- Implement and verify
- The agent makes the smallest useful diff, then `agentloop verify` runs your configured checks and captures the result. `agentloop status` and `agentloop next` report where the work stands and the next local command, without running tests or calling an LLM.
- Gate before you claim done
- `agentloop check-gates` confirms a contract, a verification report, a handoff, harness files, and core policies are present. `--strict` turns missing warning gates into a nonzero exit, so review-evidence gates a pull request in CI.
- Hand off with evidence
- `agentloop handoff` writes a reviewer summary from git state, the active contract, and the latest verification report. `report` adds a browser-readable HTML page and `release-notes` drafts notes from the same local evidence.
Trust
No install scripts. No telemetry. No cloud.
AgentLoopKit only writes transparent repo files when you run it. Nothing runs on install, and nothing leaves the machine.
- No install scripts, no telemetry
- The package has no postinstall script, no telemetry, no cloud backend, no database, and no API key requirement. `npm install agentloopkit` runs no AgentLoopKit code, and no command makes a hidden network call.
- Preview before you write
- `agentloop init --dry-run` previews every file change without touching the repo. `init` appends to an existing `AGENTS.md` instead of overwriting it, and writes into the current directory only.
- Local-only when you want it
- `agentloop init --local-only` writes the same harness, then excludes `.agentloop/`, `AGENTS.md`, `AGENTLOOP.md`, and `agentloop.config.json` from this clone through `.git/info/exclude`. It does not edit `.gitignore`, global Git config, or shell profiles.
- Reads only what you point it at
- `verify`, `status`, `next`, and the MCP server do not read `.env` contents or print arbitrary environment variables. `doctor` lists risk-file paths by category (migrations, auth, deploy, lockfiles, env) without reading their contents.
Make coding agents leave reviewable work behind.
Run one command in an existing repo to install the loop, then specify, verify, and hand off. Local-first, MIT, no cloud.
Preview the harness
Install the loop
Scope a task contract
Run configured checks
Gate review evidence
Hand off to a reviewer
Install agent instructions
Start the read-only MCP server
More from the studio
ProjScan
Agent-first code intelligence and Mission Control for developer agents. ProjScan turns a plain-language goal into a mission, a local proof loop, a review gate, and a resumable handoff, all over MCP with no source upload.
View
TokenTrace
Reads what Claude Code, Codex, and other AI CLIs write on disk. Shows cost, models, projects, and sessions in a local dashboard. No cloud, no telemetry.
View
Swiss Auto Data
Daily-refreshed registrations, EV adoption, and cantonal breakdowns drawn straight from government data.
View