Skip to main content
CLI · Open source Composable loop framework No prompts after launch Free · no account

A composable loop framework for autonomous coding.

Ralph Workflow is a free, open-source composable loop framework and AI agent orchestrator for substantial, well-specified software engineering work. It gives developers a practical path to vendor-neutral AI coding workflow automation with policy-driven structure and checkpoint/resume confidence: give it a real backlog task before bed, and it plans the work, writes the code, runs your tests, and fixes anything that breaks while your computer stays awake. You wake up to finished code you can open, run, and review.

Plan

Your task description gets tightened before a single line of code runs — gaps and missing expectations are surfaced early so the result actually matches what you asked for.

Build & test

Code gets written, your test suite runs, failures get fixed — all in a single loop with no babysitting from you.

Finished code

Real changed files in your project folder — open them in your editor, run the tests yourself, and decide: merge it, or sharpen the task description and re-run.

Codeberg is the primary repo. GitHub stays available as the mirror.

Best evaluator path: inspect the primary repo on Codeberg, copy a first-task shape, run one real backlog task overnight, then ask one question in the morning: would I merge this?

An example overnight run — before you install anything

From task description to finished, tested code — the example run.

example job walkthrough

example sequence

ralph
Add a billing history page with filters, empty state, and export link.
2 gaps found and fixed before any code runs.
Plan updated and approved for development.
Updated controller, page template, and tests for the new billing history flow.
Tests pass, code reviewed. Ready to open and merge.
a3f1c2e · changes ready to review and merge.

See the proof on the page — plan, build, and verify — before you install a thing.

Read the full walkthrough →

Sound familiar?

You write a task. The AI starts. You answer a prompt. Then another. It hallucinates. You correct it. You’re still there at midnight babysitting a tool that was supposed to save you time.

There’s a better way. Hand off one real task before bed — Ralph Workflow plans it, builds it, tests it, and fixes anything that breaks while the computer stays awake. You come back to code you can review instead of another late-night back-and-forth. No prompts. No babysitting. No midnight sessions. Usually costs less than a dollar in API credits.

The old way

Write task → AI drafts → you check → you prompt → AI tries again → (midnight) → still not done

With Ralph Workflow

Write the task → run Ralph Workflow → keep the computer awake → wake up → open the result → merge or re-run

Simple at the center

A composable loop framework for real software engineering.

Ralph Workflow takes the simple Ralph-loop idea and turns it into a composable loop framework for real software engineering. Every phase is its own loop — plan, build, verify — each one completing cleanly before the next begins. That simple core is what makes the system easier to reason about, extend, and trust. Start with the default workflow and run it as-is. When you need more, extend or reconfigure it — the loop structure stays the same.

This is why Ralph Workflow is an orchestrator and not a coding chat or a thin wrapper. The loop structure keeps planning honest and development disciplined — the result is finished code you can actually open and run.

Planning loop

Tighten the task before any code runs

Gaps and missing expectations get surfaced and closed early — so the result actually matches what you asked for.

Build loop

Write, test, and fix — in the same loop

Code gets written, your test suite runs, and anything that fails gets fixed before the loop hands back — all without you touching the keyboard.

Composable by design

Start with the default. Extend when you need to.

The shipped workflow is already strong for real software work. Build on top of it only when you need to — the simple loop structure stays the same whether you change anything or not.

If this is what you were searching for

Looking for an unattended coding agent, a spec-driven AI agent, or an AI agent orchestration CLI?

Ralph Workflow is a Codeberg-first open-source path for that exact job. If you are looking for Claude Code unattended, Claude Code automation, AI coding workflow automation, or an AI agent workflow composer, this is built for the morning-after question that matters: did you get specific, tested code that is ready to review and honest enough to merge?

Fastest proof path

How you get there

Three phases. No prompts after launch. Finished code by morning.

Three phases run automatically, back to back — each one a disciplined loop that completes cleanly before the next begins. No manual steps, no gaps for things to slip through. Plan until it is concrete, build until the tests pass, then stop and hand it back.

1

Sharpen the task — before a single line is written.

Your task description gets pressure-tested before a single line of code runs. Gaps get surfaced and closed. The clearer your description, the better the result — and the easier it is to judge in the morning.

If the request is weak: the work stays in planning until it is specific enough to build and honest enough to judge. A clear done condition is the difference between a useful result and a confusing one.

2

Build, verify, and fix — in the same loop.

Code gets written, your test suite runs automatically, and anything that fails gets fixed in the same loop. You don’t see a broken result — the loop handles it before handing back.

If the change is weak: it gets fixed before it moves on.

3

Finished, tested code in your project folder — open it, run the tests, and make the call.

You get real, focused code changes committed to your project — tested, traceable, and ready to open in your editor. The work is done; the decision is yours.

What you open in the morning: committed, tested code — run the tests yourself and decide whether to merge.

Why it matters

Other AI tools give you a start. Ralph Workflow gives you a finish.

Most AI tools hand you a draft and wait for your next prompt. Ralph Workflow keeps going — plans, builds, tests, and fixes — and hands back finished code you can actually open and judge. Discipline and leverage, not magic.

vs hovering over every step

No prompts. No monitoring. No midnight sessions. Start the job, keep the computer awake, and come back to a result you can actually judge.

You are completely free to step away — no watching the terminal, no answering prompts. The work runs unattended from start to finish.

  • No prompts after launch — fully unattended from start to finish.
  • Resume mid-job without re-doing work already done.

vs managing it yourself

Ralph Workflow wraps your agent in a structured loop — it plans before building, tests before finishing, and hands back something your engineer judgment can actually evaluate.

The composable-loop structure keeps planning honest and the build disciplined — so the result is not just more AI output, but something grounded in a spec, verified by tests, and traceable in your project.

  • Planning loop tightens the spec before any code runs — no guesses, no drift.
  • Build loop runs your tests and fixes failures — results that already passed your suite before you open them.

Start tonight. Judge tomorrow.

One task. One overnight run. Pick something substantial and review it by morning.

The best first task is a meaningful one: big enough to matter, specific enough to describe in a paragraph, and familiar enough to judge the result.

Pick the right first task

Pick a real task you actually want done — familiar enough to judge the result, bounded enough that a bad first run would be cheap to reject.

Real work Low risk Easy to verify

1. Pick a real first task

Choose a real first task — meaningful enough to matter, specific enough that you can tell whether it worked.

Start smaller than your eventual use case. Integration tests, one feature slice, or one bounded refactor are ideal first runs because the morning-after judgment is cheap and honest. After that, Ralph Workflow can graduate to the bigger feature, migration, or repo-scale cleanup. One clear “done” condition = one clean judgment call the next morning.

2. Write down the job

Write it like a handoff note: what changes, what stays, and what done looks like.

One clear paragraph is enough. The clearer your description, the cleaner the result — and the easier it is to judge in the morning.

3. Judge the morning-after result

Open the result, run the tests. Would you merge it? That is the whole evaluation.

If you would merge it, give it a harder task next time. If not, rewrite your task description and re-run — the second attempt is almost always better because you now know exactly where the gap was.

The one question that matters

Would you merge it? If yes — hand it something that matters. If no — you now know exactly what to sharpen. Either way, one overnight run taught you something real.

Start with pipx install ralph-workflow

Works with the tools you already trust

No need to switch tools. Ralph Workflow works with what you already use.

Plug in the agent you already use — Claude Code, Codex CLI, or OpenCode. Ralph Workflow handles the workflow with a policy-defined loop, so your tools stay the same while the handoff gets more reliable. Resume interrupted runs, swap providers without rewriting your process, and review something you can actually open, run, and merge.

Trust boundary

Keep your existing agent setup. Keep your keys to yourself. Ralph Workflow works through the coding agents you already trust instead of turning “hand over your API keys” into the main setup story.

Why people try it

  • Stay vendor-neutral — keep the CLI and provider choices you already trust.
  • Reuse your existing agent login and provider path instead of re-entering secrets into a new hosted layer.
  • Get set up in under five minutes, then let it run overnight while the computer stays awake.
  • Use the default workflow now, then tighten it into a policy-defined review loop or resume mid-job when a run gets interrupted.

Runs on your machine

Local-first. Your code never leaves your environment.

Checkpoint & resume

Never lose progress, even if your machine restarts.

Vendor-neutral

Bring your existing agents — Claude Code, Codex CLI, OpenCode.

Claude

Anthropic — Claude Code

Strong planning and long context — produces cleaner, review-ready changes.

OpenAI

Codex CLI & GPT

A solid choice for OpenAI-first teams. Works with Codex CLI and the wider GPT model family.

OpenCode

Multi-provider gateway

Routes jobs across multiple providers — swap models without reconfiguring your entire workflow.

No new tools required — use the agent you already trust. The only question is whether the result meets your standard for done.

FAQ

Straight answers to the questions you actually asked.

Cost & privacy

Does it change my code automatically?
No. You review every change before anything lands. Ralph Workflow finishes the work — you make the call.
Is there a subscription?
No. Free to install, open source. You pay only your AI provider’s API fees — nothing else.
Can I read the source before installing?
Yes. Every line is public on Codeberg. Read it, inspect it, trust it — before you run a single command.
Does my code leave my machine?
No. Ralph Workflow runs entirely on your machine. Your code never reaches any Ralph Workflow server. You are only paying for your AI provider's API — and that API call happens directly between your machine and your provider.
Is it safe to use on a private codebase?
Yes. Ralph Workflow runs entirely on your machine — no data leaves your environment. Your code stays in your project folder, accessed through your existing git remote. There is no Ralph Workflow cloud service, no external server, and no third party that sees your code unless you choose to push it.

Getting started

Does this replace my AI coding tool?
No. Ralph Workflow is workflow automation — it wraps your existing agent (Claude Code, Codex CLI, OpenCode) in a structured loop so you get a finished result instead of another chat session. Your agent stays the same; Ralph Workflow adds the structure around it.
How is this different from just prompting my AI tool?
Prompting is interactive — you answer prompts until the session ends, then start again. Ralph Workflow runs unattended: plan, build, verify, and hand back. No prompts after launch. You get a finished result in the morning instead of a half-done session you have to babysit.
Is this only for big tasks?
For your first run, it works best on something meaningful but easy to judge — one test gap, one bounded feature slice, one contained refactor, or one backlog fix with obvious acceptance criteria. After that, you can hand it larger features, migrations, or repo-scale cleanup. Tiny edits and one-off commands are still weak fits, but your first run should be bounded before it is ambitious.
Does my computer need to stay on overnight?
Yes — the computer needs to stay awake and connected to power. You can step away from the terminal, leave the room, even close the lid — just make sure it is plugged in and not set to sleep. Laptops should be in clamshell mode or at least set not to sleep. If the machine goes to sleep, the job pauses and resumes when it wakes — no work is lost, but the timeline extends.

Results & expectations

What if the result is not good enough?
Sharpen your task description and run it again. The second attempt is almost always better because you now know exactly what gap the first run exposed. Ralph Workflow commits every change so you can see exactly what was built and trace any gap back to the original task description.
What does a finished run actually look like?
Committed, tested code in your project. Open your editor, run the tests, and see exactly what changed. No giant log files to read. No ambiguous summaries. Just files you can open, diffs you can review, and a test suite that tells you whether the result holds.
What if my project does not have tests?
The work still finishes — code gets written, files get committed. But the result is honest: if your repo lacks tests, Ralph Workflow cannot verify with tests. That is a signal, not a failure. Add a test suite and the build loop will use it.

Start tonight

Pick one real task. Wake up to finished code.

Install tonight. Pick one substantial task. Review the result by morning.

Free to install · uses your existing AI agent · your code never leaves your machine

Source is public on Codeberg Runs on your machine Free forever, no subscription

Best evaluator path: inspect the primary repo on Codeberg, pick one bounded task, then install and run it tonight. GitHub stays available only as the mirror.

Free to install. No account needed. Your AI provider’s API is the only cost.