Tickets go in.
Releases come out.
loopy turns your project board into shipped software — planned, built, adversarially reviewed, merged and released, on your GitHub Actions with your Claude subscription. While you sleep.
Licensed engine, runs entirely in YOUR environment · No inference resale — your models stay yours
One ticket. Seven steps. Zero babysitting.
Every card on your board rides the same disciplined lifecycle — the one printed on our robot. Each step leaves an audit artifact, because a claim without evidence is just vibes.
Reads the ticket
Picks the next card from your board — GitHub Projects or Jira — and understands the goal, the constraints, the acceptance gates.
Plans like a staff engineer
A frontier planning model writes an implementation plan that cites real files and lines — and corrects the ticket when the ticket is wrong.
Plan review, enforced
No code before an approved plan. Reviews verify every cited claim against the tree; amendments reach the executor verbatim.
Builds tests-first
An execution-tier model implements in a sandboxed container on your runner — red tests before code, your verification gate before any PR.
Adversarial review cycles
Bot review findings are triaged claim-by-claim — verified, applied or refuted with evidence — until the head is green and every thread has a verdict.
Merges & releases
Strict convergence merges; semver is decided mechanically; the release cuts itself; the card sweeps to Done.
Shows its work
A run report lands on every PR — rounds, verdicts, cost, wall-clock, and what was not done. Honesty is a feature.
Autonomy with a paper trail.
Plan-review gates
Every plan is verified against the actual tree before approval. Wrong ticket premises get caught before they become wrong code.
Convergence, not hope
PRs merge on strict convergence: reviewed head, every finding adjudicated, green gate. A red check blocks a merge no matter who says otherwise.
Run report cards
Machine-derived audit artifacts on every PR — review rounds, verdicts with links, effort estimates, and honest gaps stated by name.
Glass containers
With LOOPY_MESH_DIR, agent sessions stream to your host live — tail any run, resume any session, message any agent. Total visibility.
Quiet when idle, loud when broken
Scheduled runs with nothing to do exit green with one notice. Real failures page you. Your inbox stays yours.
Model tiering
Frontier model plans, execution tier builds — per-ticket routing with a floor your org sets. Spend brains where brains matter.
Your infra, your keys
Runs on GitHub-hosted or your self-hosted runners. Uses your Claude subscription. Your code never transits our servers — we don’t have servers in your loop.
Fleet operations
Drive many boards as serial lanes with one autopilot: dispatch, nudge, merge, sweep, escalate — every write behind a policy gate you enable one at a time.
This website is ticket #1 on its own board.
loop-ops.ai is maintained by the pipeline it sells: improvements are filed as tickets, planned by the planner, gated by plan review, built by the executor, converged and released — then this page updates itself. We don’t demo the product. You’re looking at the demo.
Bring your Claude. We bring the discipline.
Competitors meter your tokens and resell inference. loopy doesn’t touch your model bill — you pay Anthropic directly, and pay us only for the orchestration layer that makes autonomy safe to run unattended.
Trial
- The complete pipeline, nothing held back
- Plan → build → converge → release
- Wired by the install wizard
- Your infra, your Claude — even in trial
Pro
- Everything in Open Core
- Report cards & audit artifacts
- Glass containers + live mesh
- Quiet-idle ops & escalations
- Jira backend
- Priority support
Fleet
- Everything in Pro
- Fleet autopilot across boards
- Serial lanes & cross-repo deps
- Org dashboards & fleet status
- Policy gates, enabled one at a time
Enterprise
- Licensed self-hosted binaries
- Air-gapped & SSO
- License health & compliance
- SLA support & onboarding
- Named upgrade path
Every tier is BYO-everything: your runners, your Claude subscription, your repos. Typical all-in cost — one Pro lane + one Claude Max seat — undercuts a single autonomous-agent seat elsewhere, and the agent works your board, not a chat window.
Fair questions, straight answers.
Does my code go to your servers?
No. loopy is a licensed engine that runs inside your CI, on GitHub-hosted or your own self-hosted runners. Inference goes straight from your runner to Anthropic with your credentials. There is no loopy server in the path.
What stops it from merging garbage?
The same thing that stops humans: gates. No execution without an approved plan, no merge without strict convergence — reviewed head, every review finding adjudicated with evidence, green verification gate. And every run posts a report card, so “done” is auditable.
How is this different from a coding copilot?
Copilots help a human type. loopy works a board: it claims tickets, plans, builds, survives code review, merges and releases — the unit of work is a shipped card, not a suggestion.
What does it cost to run?
Your existing Claude subscription (or API key) plus your CI minutes — self-hosted runners make those free. loopy itself never meters your tokens.
Can I watch it work?
Yes — glass containers stream every agent session to your machine live: tail the transcript, resume the session, message the agent. Autonomy shouldn’t mean opacity.
Stop reviewing unshipped work.
Put a ticket on the board tonight. Read the release notes tomorrow.
Open the app → hello@loop-ops.ai