Grounding
Repo + ops state
Workspace files, issue context, prior handoffs, rules, skills, and budget state are the source of truth for each step.
Ground agents in your repo, issues, skills, and tools. Keep execution local-first, push decisions through budgets and guardrails, and drive the loop from chat or CLI when judgment is required.
AI agent frameworks help you build agents. They don't tell you how to run one safely at 3 a.m. when nobody's watching the API bill. loopctl does — hard budget caps, per-cycle spend enforcement, blocked-branch guardrails, rollback tags on every cycle, and a messenger control plane you can drive from anywhere.
loopctl gives autonomous work a clean operating model: select the next unit of work, assemble grounded context, enforce policy, run the agent with live tools, and leave a durable record operators can inspect or resume from any surface.
Workspace files, issue context, prior handoffs, rules, skills, and budget state are the source of truth for each step.
loopctl assembles role, task, policy, and prior outputs up front. The agent reads the repo and live state through shell, git, GitHub, and MCP tools as it works.
Control plane, logs, queues, and workspace stay close to the repo. GitHub, Telegram, Slack, Mattermost, MCP servers, and deploy targets stay remote behind adapters.
Everything you'd otherwise cobble together yourself for an unattended coding agent — in one binary + one YAML file.
Daily and per-cycle budgets enforced mid-stream. Hard caps kill a cycle the moment it runs out; override on demand from bot or CLI when you want to.
Blocked commands (rm -rf,
git push --force).
Blocked branches — never direct to main. Blocked file patterns — secrets + CI stay human-only.
Approval gates on any step. Break-glass PIN for emergency pause from chat.
30+ Telegram, Slack, and Mattermost slash commands. The same verbs work from the CLI — parity is contract-tested, so anything you do on your laptop works from your phone.
Multi-agent workflows where each step has a named role, per-step handoff, per-role model and effort, optional human approval gates, and a control plane that decides when to hand work forward, hand it back, or pause for judgment.
Every cycle tagged in git. commit_push_pr
policy plus blocked-branches plus GitHub branch protection — three layers. One-command rollback.
Not a coding assistant. Software, docs, support triage, ops monitoring — skills define what the agent does; the framework handles the loop, the bot, and the guardrails.
20+ skills ship in the box — scan-and-fix, chat, team pipelines, audit runners. Three
scopes: framework (built-in),
project (operator-local),
dev-time (maintainer-local).
Override any shipped skill by dropping the same-named file in your
.agentic/skills/.
No forking required.
Claude, Codex, Gemini, Grok, OpenAI, and Ollama out of the box — plus custom commands for anything else. Adapters plug in behind one interface; the loop, the bot, and the guardrails don't care which brain you wire up.
Install any Model Context Protocol server with agentic mcp install.
Every pipeline agent gets the same tools — GitHub, Jira, Linear, your own — with the
same auth, no wrapper code. Same adapter pattern, different endpoint.
A loop can run for hours without you. When it touches a protected file, asks for a risky command, crosses a budget boundary, or reaches a review step, it pauses and asks a named human to approve, reject, or edit the handoff. Omit the setting for a fully autonomous step; add it where human judgment is part of the workflow.
organization: pipeline: [pm, dev, reviewer, lead] agents: - name: dev # no approval key: autonomous unless a guardrail pauses it - name: reviewer approval: human # by design: wait for a person
loopctl is a narrow tool. If one of these sounds like you, use something else — we'll save you time.
Something that helps you write the next line of code while you're in-flow. loopctl doesn't do that.
Use Claude Code, Cursor, or Aider.
Upload a task, come back to a PR, no infra to manage. loopctl runs on your machines — you own the containers, the logs, the secrets.
Use Devin, AgentDock, or an enterprise agent-fleet SaaS.
loopctl assumes you've already shipped something with a coding agent and now want to run it unattended. The onboarding curve is not gentle.
Start with Goose or Claude Code for a few weeks first.
Define who does what in YAML — write it yourself, or run
/setup-pipeline
inside Claude Code and let the skill interview you about domain, risk, and budget,
then write the organization
block for you. Either way, the pipeline runs what you produce. One agent or twenty —
any shape, any domain. Each agent gets its own model, effort, skills, and personality.
Change the shape without rewriting code.
# Hand-written below, or generated by running `/setup-pipeline` # inside Claude Code — either way the output lands here. organization: pipeline: [pm, dev, reviewer, lead] agents: - name: pm role: orchestrator model: claude-opus-4-7 effort: max description: >- Reads backlog, picks target, writes spec. skills: [team-orchestrator] - name: dev role: developer agent: codex model: gpt-5.4 effort: high description: >- Implements the spec. Knows when to ask back. skills: [team-developer] - name: reviewer role: reviewer model: claude-opus-4-7 effort: max approval: human # optional: require a person here description: >- Naming, invariants, security. No emotion. skills: [team-reviewer] - name: lead role: lead agent: codex model: gpt-5.4-mini effort: medium description: >- Final SHIP or HOLD. Sees the full output. skills: [team-lead]
Solo is one agent. Team is a flat list. Enterprise is nested departments. Scale the shape to the problem; the framework doesn't care.
Opus where judgment matters. Codex where implementation or fast lead checks fit better. Set agent, model, and effort per role in YAML — no code rebuild.
Each agent gets only the skills (markdown playbooks) it needs. Description sets tone and approach — the reviewer isn't the dev isn't the lead. Handoff between steps is structured, not just context dump.
Omit approval and the step runs on its own.
Add approval: human when review is part of the
design, or let guardrails pause the loop only when something breaks policy. Approve,
reject, or edit from Telegram / Slack / CLI.
Write the YAML yourself, or run
/setup-pipeline
in any Claude Code session. The skill interviews you, proposes a shape, explains
the trade-offs, and writes it into your
.agentic/config.yml.
Ship working code from issue to PR.
pm → dev → reviewer → qa → lead
Editor plans, writer drafts, fact-checker verifies, lead signs off.
editor → writer → checker → lead
Triager reads alerts, investigator finds cause, fixer patches, postmortem writes.
triager → investigator → fixer → postmortem
Three layers every cycle flows through: what comes in, the controls you hold, and the audit trail that comes out. Nothing happens that isn't logged, capped, or revertable.
> watch production. ping me if a cycle fails. Tailing production-progress.log, watching for result=failed… [19:35] ✓ cycle-1776794642 · #510 · PR #536 [19:42] ○ cycle-1776795882 · scotty step 2 [19:47] ✓ cycle-1776795882 · $4.12 · PR #537 [19:58] ✓ cycle-1776796410 · $2.80 · PR #538 All green. 3 PRs in 23m, $6.92 spent. >
agentic ops tail --all-projects [production] 19:42 Step 2/6 — scotty [production] 19:42 reading loop/loop.go [staging ] 19:43 cycle result=success [dev ] 19:43 auto-pick from backlog [production] 19:44 Step 3/6 — geordi [production] 19:46 Step 6/6 — picard [production] 19:47 Pipeline completed 5m32s [production] 19:47 PR #537
agentic ops tail --all-projects --filter events [production] 19:35:12 cycle-1776794642 result=success · PR #536 · 31m32s · $4.12 [production] 19:42:03 cycle-1776795882 Step 1/6 — riker [production] 19:42:47 cycle-1776795882 Step 2/6 — scotty [staging] 19:43:11 cycle-1776795934 result=success · $0.93 · 2m26s [staging] 19:43:12 PR-error: no commits between main and branch [dev] 19:43:39 cycle-1776795966 auto-pick from backlog [production] 19:44:51 cycle-1776795882 Step 3/6 — geordi [production] 19:45:55 cycle-1776795882 Step 4/6 — data [production] 19:46:22 cycle-1776795882 Step 5/6 — spock [production] 19:46:59 cycle-1776795882 Step 6/6 — picard [dev] 19:47:20 cycle-1776795966 result=success · $0.71 · 2m8s [production] 19:47:31 cycle-1776795882 Pipeline completed 5m32s [production] 19:47:32 cycle-1776795882 result=success · PR #537 · $2.80
19:42:03 Step 1/6 — riker (Project Manager) model=opus-4-7 · effort=max reading backlog, selecting highest-value target… → picked #510 (pipeline phase transitions) 19:42:47 Step 2/6 — scotty (Senior Developer) editing loop/loop.go, orchestrator/pipeline.go → core impl + unit tests · 2m14s · $0.84 19:44:51 Step 3/6 — geordi (Developer) polishing edges, adding step-lock TTL → refinements + table tests · 1m4s · $0.42 19:45:55 Step 4/6 — data (QA Engineer) running test suite, static analysis → all 383 tests pass · 27s · $0.15 19:46:22 Step 5/6 — spock (Senior Code Reviewer) code-quality review, naming, invariants → 0 findings, approved · 37s · $0.29 19:46:59 Step 6/6 — picard (Engineering Lead) model=opus-4-6 · effort=max reading full pipeline output, final verdict… → SHIP IT · 32s · $0.21 19:47:31 Pipeline completed in 5m32s · $2.80 total 19:47:32 PR https://github.com/LoopCtl/agentic/pull/537
Click the tabs above to switch views.
The diagram above shows one loop in one env. Real deployments run N envs, multiple loops inside each env, and can fan out parallel steps within a single pipeline. Same config surface for all three shapes.
One env, three loops. Fast pipeline for urgent fixes. Main pipeline for planned work. Nightly audit. Each with its own cadence, pipeline shape, and budget — they share the env's workspace and secrets.
Same pipeline, parallel steps. Two devs split the implementation. Two QAs run the test matrix in parallel. The reviewer and lead stay sequential because they need the full picture. Fan-out / fan-in declared in YAML, same surface as sequential steps.
interval (e.g. 30m) wakes a cycle.
/scan, /fix <issue>, /force.
agentic ops cycle.
cycles_per_hour · cycles_per_daydaily_spend · per_cycle_spend/loop on|off · /pause · /cancel/god — bypass caps for one incidentops config cycles_per_day 20 — retune liveAgentic-Cycle · Agentic-Agent · Agentic-Model · Agentic-Skill · Agentic-Role.
agentic:in-progress, comments progress, clears the label on PR merge. Anyone reading the issue sees the full arc.
agentic-cycle-<id> — rollback to any point with one command.
Everything loopctl produces is grep-able from the moment it lands. Three surfaces, same audit trail:
git log --grep='Agentic-Cycle: ...'
every commit from one cycle · every commit from one agent
gh issue view 510 --comments
the agent's own progress narration on the issue thread
jq '.result' production-cycles.jsonl
success / failure counts from the event log
Nothing anonymous lands in your repo. Nothing hidden from the issue thread. Nothing unlogged.
Five tools closest to loopctl in shape and intent — the architectural peers. Honest framing per row: what they're great at, where loopctl differs, who should pick which. For tools you may also be evaluating but that solve different problems (Cursor, Claude Code, Devin, Goose), see “Who this isn't for” above — those are different jobs, not direct comparisons. Assessments dated 2026-04; verify against current docs.
| Tool | Shape | They're great at | What loopctl adds | Pick which |
|---|---|---|---|---|
| loopctl | Self-hosted ops control plane | Scheduled scan loop · messenger ops · commit provenance · tracker timeline per cycle · controller/worker publication | — | “AI runs my project overnight” |
| Gas Town | Multi-agent workspace coordination (OSS) | Persistent named agents in towns/rigs · git-backed work state via Beads · mailbox-style handoff · supervisor/watchdog patterns · refinery-style merge queue | Scheduled scan loop on top of workspace coordination · messenger ops with CLI parity contract · per-cycle + daily cost governance · provenance per commit (named role trailers) · tracker timeline per cycle | Gas Town to coordinate persistent named agents across parallel workspaces. loopctl when you want the operations layer (scheduling, messenger, audit, publication) on top. |
| Gas City | Multi-agent orchestration SDK (OSS) | Lower-level building blocks behind Gas Town — runtime providers, controller/supervisor reconciliation, work routing, mail/formulas/orders integration with Beads | Ready-to-run ops platform — no SDK assembly required · scheduled scan loop with messenger ops · per-cycle + daily cost governance · provenance per commit · tracker timeline per cycle · built-in guardrails + approval gates | Gas City to assemble your own custom orchestration. loopctl when you want a working ops platform without building it. |
| OpenHands | OSS agent platform | Larger contributor community · mature multi-agent SDK · polished local GUI · K8s enterprise story · Slack / Jira / Linear cloud integration | Scheduled scan loop — not interactive-first · CLI ↔ bot parity contract enforced by tests on every PR · provenance per commit (named role trailers) · per-cycle + daily cost governance · tracker timeline per cycle | OpenHands to build into a platform with a richer agent SDK. loopctl as an operations layer your agent runs inside. |
| Composio Agent Orchestrator | Parallel coding-agent orchestrator (OSS) | Per-worker worktree + branch + PR · CI/review feedback routed back to agents · local dashboard with desktop notifications · tmux/Docker runtime | Scheduled scan loop on top of parallel workspaces · bidirectional messenger ops over Slack / Telegram / Mattermost (not desktop notifications) · per-cycle + daily cost governance with mid-stream circuit breaker · provenance per commit · tracker timeline per cycle | Composio Agent Orchestrator to supervise N parallel coding agents from a dashboard. loopctl when you want operations, budgets, and audit on top. |
| Loki Mode | Multi-agent app generator from spec | Turns a written specification into a working app — source code, tests, CI, audit log · multi-agent cycles · provider failover | Continuous ops on your existing project — not one-shot generation from a spec · scheduled scan loop against your backlog · messenger ops with CLI parity · per-cycle + daily cost governance · provenance per commit · tracker timeline per cycle | Loki Mode to generate a new app from a written spec. loopctl to run agents on your existing project's issues 24/7. |
Method: assessments reflect best-effort reading of each tool's public positioning + docs as of 2026-04. The agent-tooling space moves fast; verify against current docs before deciding.
Tools we've researched that sit in adjacent categories — complementary, niche, or solving a different problem. Grouped by shape so you can see what each one is actually for, not just how it scores on loopctl's axes. Per-row “when to pick” honestly points at the alternative when it's the better fit.
| Tool | Best at | Stack | When to pick |
|---|---|---|---|
|
Self-hosted autonomous loops
Other autonomous-loop tools that didn't make the head-to-head above
|
|||
| Ralph | Bash script that keeps re-running an agent against a fixed task list until every item is marked done | Shell + JSON task file + git history | You want the loop concept only and will build your own ops layer |
| NVIDIA NemoClaw | Open privacy/security wrapper around autonomous agents, using NVIDIA's Nemotron open models | Open source; designed for local NVIDIA compute | You need privacy/policy enforcement on top of an open autonomous agent stack |
|
Workspace managers
Other tools for supervising agents across parallel git workspaces
|
|||
| Claude Squad | Terminal UI to spin up and supervise several agent sessions side by side, each in its own git workspace | tmux + git workspaces | You want a TUI to babysit several manual sessions at once |
|
Hosted SaaS alternatives
Vendor-managed — trade infra control for zero-setup
|
|||
| Devin | Hosted autonomous coding agent — upload a task, come back to a PR, no infra to manage | Vendor cloud, per-seat pricing | You want autonomous coding without operating any infrastructure |
| AgentDock | Visual / no-code agent builder + workflow chains, hosted | Vendor cloud, free + paid Pro | You want a no-code visual builder over OSS code-self-host |
| Runloop | Managed sandbox compute for agents to run tools in — an infrastructure layer, not an agent itself | Vendor cloud, enterprise pricing | You need agent sandbox compute as a managed primitive |
| MuleSoft Agent Fabric | Enterprise agent control plane with token tracking and LLM governance, embedded in Salesforce | Salesforce cloud, enterprise | You're a Salesforce shop and need an enterprise control plane |
| Kore.ai | Enterprise conversational AI + agent platform with hosted orchestration and ecosystem integrations | Vendor cloud, enterprise pricing | You're enterprise and want a hosted agent platform with vendor support |
|
Interactive agents — you drive these by hand
Inference primitives loopctl can run as adapters when you want them automated
|
|||
| Cursor | AI code editor (VS Code fork) with Composer background-task agents and real-time pair programming | Proprietary IDE, cloud + local agents | You want AI in your editor, not on your infrastructure |
| Claude Code | Anthropic's first-party CLI agent for coding — structured tool use, first-class Claude API access | CLI binary, Claude API | You want to drive Claude interactively — or run it as the agent loopctl invokes |
| Goose | Native desktop + CLI agent with MCP-first design and Linux Foundation governance | Rust binary + MCP extensions | You want an interactive agent with strong OSS governance — or run it via loopctl |
| Pi | Interactive terminal coding agent with branching conversation history; supports many model providers | Node.js CLI + TypeScript extensions | You want an alternative interactive terminal coding agent |
| pi-mono | Toolkit behind Pi: the CLI, a unified LLM API, TUI/web libraries, a Slack bot that delegates to the CLI | Node.js / TypeScript modules | You want Pi's broader toolkit, not just the CLI |
| Antigravity | Google's IDE for AI coding, with a panel that orchestrates multiple agents on one task | Google platform, public preview | You're inside Google's ecosystem and want IDE-integrated multi-agent |
|
Skill bundles — extend an existing agent
Workflow + instruction assets that drop into Claude Code, Pi, or similar
|
|||
| gstack | Disciplined plan / build / review / canary slash commands for Claude Code | Markdown skills in Claude Code | You already use Claude Code and want structured commands for development phases |
| pi-skills | Skill pack — web search, browser automation, Gmail/Drive, VS Code, YouTube transcripts — that works across multiple agent harnesses | Markdown skills (Pi / Claude Code / Codex CLI / Amp / Droid) | You want portable skills that work across several coding agents |
| Superpowers | Skills framework + opinionated software-development methodology you install into your agent | Local plugin / skill install | You want a methodology layer on top of an existing coding agent |
| BMAD Method | Agile AI-development method with specialized role agents and workflows you install into your agent | Local install in supported coding agents | You want an Agile-flavored multi-agent process imposed on your tooling |
| Spec Kit | Toolkit + slash-commands for spec-driven development — write the spec first, then have the agent implement it | CLI + local agent integrations | You want spec-first workflows guiding the agent through phases |
| Everything Claude Code | Curated bundle of Claude Code productivity assets — skills, instincts, memory, security patterns | Local Claude Code assets | You want a grab-bag of Claude Code productivity assets in one place |
|
Agent frameworks — libraries to build with
SDKs you import into your own code, not daemons that run agents
|
|||
| CrewAI | Library for assembling multi-agent flows in code, with task chaining and memory stores | Python library, open core + paid cloud | You're writing Python and want to build multi-agent flows in code |
| LangChain | Python / JS framework for building LLM apps; multi-agent orchestration via LangGraph; massive integrations ecosystem | Python + JavaScript libraries; LangSmith SaaS for tracing | You're writing Python or JS and want the broadest LLM-tool ecosystem to build agent apps in code |
| Microsoft Agent Framework | Multi-agent orchestration library; the merger of Microsoft's AutoGen and Semantic Kernel | .NET + Python library | You're in the Microsoft stack and want a first-party agent SDK |
|
Memory / state infrastructure
Persistence layers, not runners — complement an existing agent
|
|||
| Task Orchestrator | Server that enforces a workflow / task graph the agent has to follow, with required notes and actor attribution | Local server (Model Context Protocol) + SQLite | You want server-enforced workflow gates that prompts can't bypass |
| Claude Mem | Long-term memory plugin: captures Claude Code sessions, compresses them, retrieves relevant context next time | Claude Code plugin, local memory store | You use Claude Code and want session memory that carries between runs |
|
Observability & personal assistants
Tracing for developers, or always-on personal AI — not coding ops platforms
|
|||
| AgentOps | Tracing and telemetry for your own agent code — per-step timing, token usage, errors | SaaS, open core + $40/mo | You've built an agent and want production telemetry |
| OpenClaw | Personal AI assistant gateway across many messaging channels — Telegram, Slack, Discord, Signal, WhatsApp, Matrix, Mattermost | Local daemon + sessions + sandbox | You want a personal assistant across many channels, not coding ops |
Your repo stays where it lives. Data never leaves your infra unless you wire up an adapter. No SaaS tier, no telemetry beacon.
Claude, Codex, Gemini, Grok, OpenAI, Ollama, plus custom commands. The loop doesn't care — adapters plug in behind one interface.
YAML for the environment, SKILL.md
for what agents do. No Python module to import, no hidden runtime to learn.
Nothing is forced. Skip the pipeline and run one agent. Skip the messenger. Skip MCP. Skip approvals. Skip the bot entirely. Start with the minimum shape you need, layer in the rest when the pain shows up.
One YAML file. One binary. Your repo, your infra, your budget caps.