Agent work-loop harnesses compared: Aura Crew, Ralph, Beads, and the bash loop
From a while-true bash loop (Ralph) to dependency-aware task trackers (Beads) to a proof-gated work-loop (Aura Crew): how the ways to run a coding agent autonomously compare, and when to use each.
A work-loop harness is whatever keeps a coding agent running task after task without a human re-prompting it each time. They range from a one-line bash loop to a full dependency-ordered, proof-gated platform. The right one depends on how much you need durability, coordination, and evidence that the work was actually done. Here's the honest landscape, cheapest to most governed.
The bash loop ("Ralph")
The simplest harness is a shell loop that re-invokes a coding agent on the same prompt: popularly nicknamed the "Ralph" loop (roughly while true; do agent -p "keep going"; done). It's brilliant in its crudeness: with a good prompt and a clean repo it genuinely gets work done. But it's ephemeral (state dies with the shell), blind (no idea another agent exists), and unverified (nothing checks whether a pass actually improved anything). Great for a scrappy solo grind; risky for anything you have to trust.
Dependency-aware task trackers (Beads)
A step up is giving the agent a real backlog with dependencies instead of one repeated prompt. Tools like Beads track issues and their relationships so an agent can pick the next unblocked task rather than whatever's on top. That solves ordering and memory: the agent stops redoing work and respects "this depends on that." What a tracker alone doesn't give you is isolation between parallel agents or a verdict on each result; it organizes the work, it doesn't prove it. (Aura imports Beads backlogs, so you can bring that structure with you.)
Cloud single-agent runners
Hosted agents (assign an issue, get a draft PR back) move the loop off your machine and add a review step. They're excellent for "fire and forget" well-scoped tasks. The trade-offs are that they're usually one vendor's agent, run in their sandbox, and give you a PR to review by eye rather than a machine-checkable proof that the goal was met. See Aura vs Devin and Aura vs GitHub Copilot coding agent for two takes.
A proof-gated work-loop (Aura Crew)
Aura Crew composes all of the above and adds the two things the others skip: coordination and proof. You hand it a stack of tasks as a dependency graph; agents claim only unblocked work, each in its own worktree, coordinated by a live team radar so they never collide; and nothing merges until the change is proven against its goal. It runs any agent (Claude Code, Gemini, Codex, Cursor) on one shared history, and the same ready-work view backs both the CLI (aura loop run) and chat (/loop).
| Harness | Ordering | Isolation | Proof | Many agents |
|---|---|---|---|---|
| Bash loop (Ralph) | No | No | No | No |
| Task tracker (Beads) | Yes | No | No | Partial |
| Cloud runner | Partial | Yes (sandbox) | No (review by eye) | No |
| Aura Crew | Yes | Yes (worktree) | Yes (verdict) | Yes |
Which to use
Use a bash loop for a throwaway solo grind. Use a task tracker when ordering and memory are the pain. Use a cloud runner for one-off, well-scoped tickets you're happy to review by hand. Reach for a proof-gated work-loop when you run several agents, can't afford collisions, and need to prove and audit what shipped. For the direct comparison to Claude Code's own loop primitives, read Aura Crew vs Claude Code loops.
Aura is fully open source (Apache-2.0): engine, CLI, desktop app and extension. The app is a free public beta for macOS and Linux.
What is an agent harness?
The code around the model that decides what it sees, when it runs again, and when it stops. The model writes the diff; the harness owns isolation, retries, the stop condition and the record. Most of the difference between agent tools is harness, not model.
Is a bash while-loop enough to run a coding agent?
For one task on one machine, often yes — a while-true around a CLI is a real harness and gets a surprising distance. What it lacks is dependency order between tasks, isolation between concurrent runs, and any record of why a change was made.
What should an agent work-loop record?
The goal it was given, the commits it produced, and the outcome of the check that decided it was finished. That triple is what lets someone else answer "why is this here" later without reading the whole transcript.
Aura Crew vs Claude Code Loops: the autonomous work-loop, compared
Claude Code defines four loop types — turn-based, goal, time, and proactive. Aura Crew is the same idea productized: a dependency-ordered work-loop with proof, collision-safety, and any agent. Full comparison.
Autonomous coding agent loops, explained: turn-based, goal, time, and proactive
A coding agent loop is an agent repeating cycles of work until a stop condition is met. The four types explained — turn-based, goal-based, time-based, proactive — with when to use each and how to keep quality high.
How to run multiple coding agents in parallel without merge conflicts
Running several AI coding agents at once collides on shared files. The fix: a worktree per agent, a live team radar, and soft-to-hard zone claims so parallel agents never touch the same symbol. How Aura Crew does it.
Goal-based agent loops: giving a coding agent a definition of done
A goal-based loop keeps a coding agent iterating until a success criterion is met. The trick is a deterministic definition of done — tests, a score, a proof — not an LLM guessing at "good enough." How to write one.