Teach Your Agent to Ship While You Sleep
Drop a task in. Agents plan, code, test, review, and open the PR. Decide which steps need your signoff. Every cycle teaches them — so the next one starts smarter than the last.
INTELLIGENT DISPATCH
Dispatch Tasks as Fast as You Can Think
One chat. Every project. Drop a request in plain English — the router picks the right project, classifies the work, and dispatches the right loop with full context. Ambiguous? It asks. No project picker, no context-switching, no cold starts.
- "Fix the auth bug from yesterday" → routes to the right repo, picks up the recent debugging context.
- "Add a checkout step like the one we launched for Acme" → finds the past task as a reference.
- "Plan the migration from Rails 7 to 8" → routes to a planning loop on the right project.
Aware of your projects, conversation history, task drafts, and GitHub today. Linear, Sentry, and Slack on the way — so "fix the latest Sentry error" eventually routes itself with the trace already attached.
- ├─ Past task #287 (auth refactor)
- ├─ PR #614 (related)
- └─ 3 recent conversation turns
RUN AUTONOMOUSLY
Set The Work. Walk Away. Or Don't.
Tasks flow through the loop without anyone clicking "next." Plan → Code → Review → Ship runs end-to-end on its own. You decide which steps need a human signoff. None? Fully autonomous. All of them? Concierge mode. Mix per project, per pipeline, per stage.
⟙ marks an optional human gate — toggle on to require approval, off to keep it fully autonomous.
AUTONOMOUS VERIFICATION
Proof of Functionality
Tests passing isn't the same as the feature working. The verification step boots the app, walks the critical flow the way a real user would, and confirms the change actually does what was asked — checkout completes, the new endpoint returns what's promised, the dashboard renders without errors. Verification failures loop the agent back to fix-it mode automatically.
- feature → logs in as a test user, walks the new checkout flow, confirms the receipt email.
- debugging → reproduces the original bug, applies the fix, confirms the bug stops.
- planning → dry-runs each phase against a staging clone before scheduling.
Browser recordings and screenshots from each verification run pipe straight into the User Manual — so the docs that ship to your users are made of footage from a verified, working version of the feature.
✔ Boot acme-api on ephemeral env
✔ Login as [email protected]
✔ Add "Solid Queue Pro" to cart · qty 1
✔ Checkout · paid via test card · 200 OK
✔ Receipt email delivered
✔ Captured 12 screenshots, 1 replay (38s)
✓ Verified · ready for review
↳ replay → docs/users/checkout.mdHow customers sign in, check out, export reports — with replay screenshots from verification.
Deploy, scale, recover. Runbook per alert.
Conventions agents inherit when they pick up work.
What we're building, why, and what's done.
AUTONOMOUS DOCUMENTATION
The Manuals Write Themselves
The loop produces four manuals as it ships, not just code — each one updated by the same loop that shipped the feature, so the docs never lag three sprints behind:
- User Manual — how people actually use your app, screenshot by screenshot, with replay clips from verification runs.
- Operator Manual — deploy, scale, monitor, recover. Runbooks for every alert that's ever fired.
- Agent Manuals — the conventions and prompts other agents inherit when they pick up work in your project.
- Living PRD — what you're building and why, kept current with every feature shipped.
FULL RECALL
Replay Every Decision The Agent Made
Every shell command, every file edit, every reasoning step is recorded. Watch a loop in real time, or replay any past loop frame by frame. When something goes sideways, you see exactly where — and the recording feeds back into the next loop, so the same mistake doesn't get made twice.
$ bundle exec rails test
↳ 312 runs, 0 failures
$ git commit -m "Migrate auth to Solid Cache"
$ git push origin feature/solid-cache
▶ opening pull request...COMPOUND CONTINUOUSLY
Cycle 100 Ships Better Than Cycle 1
Profiles encode framework conventions. Project memory captures yours. Reviews and corrections feed back in — automatically. Every loop teaches the next one, and the gains compound across the team and across agents. You're not training one agent — you're growing institutional memory for your codebase.
CUSTOMIZE COMPLETELY
Every Knob Is Yours To Turn
Author your own pipeline stages. Bring your own dev image so agents work in the same container you ship to. Run everything on your own Kubernetes cluster. Drive it from a CLI or API. Rotate any of it without rebuilding from scratch.
- ↳ Pipelines — author stages beyond feature, debugging, planning. COMING SOON
- ↳ Dev Images — per-project Docker images for internal tooling. COMING SOON
- ↳ Compute — your Kubernetes cluster, encrypted kubeconfig. AVAILABLE
- ↳ Transport — REST API today, first-party CLI coming. BETA
# compose your own pipeline
$ loopcontrol pipeline run feature \
--agent claude \
--image registry.acme/dev:latest \
--cluster ops-prod \
--gate reviewPICK YOUR AGENT
Match The Model To The Work
The loop is agent-agnostic. Whichever agent runs a task inherits your profile, your project memory, and your team's accumulated feedback — so swapping agents doesn't reset what they've learned.
Claude Code
Anthropic's agentic coding tool. Today's default. Strong at long-context reasoning and large refactors.
Codex · Goose · Pi
OpenAI Codex, Block's Goose, Inflection's Pi, and other agent/model combos on the way.
Per-Stage Selection
Plan with one agent, code with another, review with a third. Match the model to the stage's cost and capability.
Bring Your Own Agent
Wire up any agent that speaks our protocol — your in-house tool, an internal fine-tune, anything. The loop doesn't care which agent runs each step.
TUNED FOR YOUR FRAMEWORK
Profiles That Speak Your Stack
Every framework has its own conventions, idioms, and gotchas. Profiles encode them once, then ship pull requests that look like your team wrote them.
Rails
Hotwire, Solid Stack, fixtures over factories, bin/ci before every PR. Omakase Rails style. RESTful by default.
Next.js · Shopify · Gems
App Router and server actions for Next. App extensions and CLI scaffolding for Shopify. Gemspec hygiene and release flow for Ruby gems.
npm · AI Agent Libs
Dual ESM/CJS builds for npm packages. Pydantic, Vercel ai-sdk, MCP servers, and structured tool calls for AI libs.
Bring Your Own Profile
Author a profile for any stack we don't ship yet. CLAUDE.md and project memory layer your conventions on top of every profile.
- Git — branches, commits, PRs
- Isolated containers, encrypted secrets
- Preview & production deploys
BUILT FOR
Ship Solo or With Friends
Engineering Teams
Scale output without scaling headcount. Agents handle routine work while your team focuses on architecture, design, and complex problems.
Solo Developers
Multiply your impact. Run multiple loops in parallel while you focus on what matters most.
Orchestration Agents
Connect your agent and delegate long-running coding tasks. Your agent creates tasks, monitors progress, and gets results without being tied up.
Simple, transparent pricing
Pay only for what you use. Scale up or down anytime.
Solo
For individual developers shipping on their own.
- Single user
- 50 hours of Cloud Task processing
- Unlimited projects
- Full API access
- Bring your own model and compute
Team
For teams that ship together.
- Multi-user collaboration
- 100 hours of Cloud Task processing per seat
- Priority support
- Unlimited projects
- Bring your own model and compute
Need something beyond our standard plans?
We offer tailored solutions for enterprise teams with custom deployment needs.
FAQ
Frequently Asked Questions
What is LoopControl?
LoopControl is an autonomous orchestration platform for AI coding agents. Drop a task in and the loop runs it: plan, code, test, review, ship — end to end, without supervision unless you want some.
What does an agent actually do without me?
It reads the task, drafts a plan, writes the code, runs your tests, reviews the diff against your conventions, and opens a pull request. Each step is recorded, so you can replay the whole thing if you want to see exactly what happened.
Can I gate parts of the loop?
Yes. Optional human approval at the plan, code, or review step — configurable per project, per pipeline, per stage. Autonomous by default; gated where you want to see things before they ship.
How do agents get better over time?
Profiles capture framework conventions, project memory captures yours, and feedback from reviews and corrections feeds back in automatically. Every loop teaches the next one — so cycle 100 ships better code than cycle 1, without you rewriting prompts.
Which agents are supported?
Claude Code today. Codex, Goose, Pi, and other agent/model combos on the roadmap — pickable per project, per pipeline, per stage. BYO-agent support is coming for in-house tools and internal fine-tunes.
Can I customize the prompts agents use?
Profiles ship with sensible defaults per framework. You can override prompts, conventions, and review rules per project — your CLAUDE.md and project memory layer on top of the base profile.
Can I add my own pipeline stages?
Feature, debugging, and planning ship today. Composable user-defined pipelines — for things like migrations, security review, or staged rollouts — are on the roadmap.
How does Cloud Task processing work?
Cloud Task hours run your loops on LoopControl-hosted compute, billed by the minute. Solo includes 50 hours/month; Team includes 100 hours/month per seat.
- ↳ Need more? Add additional cloud hours at any time.
- ↳ Want unlimited? Connect your own Kubernetes cluster — when loops run on your compute, there are no usage limits and no per-task billing.
Can I run agents on my own Kubernetes cluster?
Yes. Connect a cluster you control via per-environment kubeconfig (encrypted at rest) and LoopControl provisions task containers there. Code, secrets, and compute stay on your infrastructure.
Can my AI agent create tasks automatically?
Yes. LoopControl exposes a REST API that lets orchestration agents create tasks, monitor progress, and retrieve results programmatically. Your agent can delegate work to LoopControl without human involvement.
Is my code secure?
Yes. Each project runs in an isolated container with its own resources, network policies, and encrypted credentials. No code or credentials are shared between projects or users.
What about my custom Docker image with internal tooling?
Per-project dev images are on the roadmap. Bring the same container your agents work in — internal CLIs, locked-down toolchains, proprietary linters all just work.
$ loopcontrol tasks create "Migrate auth to Solid Cache" --project=acme-api --kind=featureStart The Loop. Stay In Control.
Drop in the work. The agent picks it up.
The next loop already knows what your team ships.