Meet Ripple: A Local-First Task Manager for Coding Agents

Local-first agent workflow

Coding agents can do impressive work. Ripple gives everything around that work a durable place to live.

The short version

Humans decide what matters. Agents handle the delivery loop. Ripple keeps both sides working from the same source of truth.

Ripple dashboard showing projects, story counts, and completion activity

Why I built it

A project should survive the chat session.

Most agent workflows begin with a chat window and a prompt. That is useful for one task, but software projects are long chains of decisions, dependencies, acceptance criteria, corrections, and follow-up work. I wanted a durable layer between the project and any single agent session: write a story once, preserve its context, put it in an intentional order, and see exactly what happened after execution began.

The task should be the durable artifact, not the prompt that happened to create it.

Backlog

Queued

In progress

Done

Closed

Human owned

Shape the backlog, choose the queue, verify the result, and close the work.

Agent owned

Implement a bounded story, report progress, respond to review, and move it toward done.

01 / Orient

One workspace for the whole project

Every connected repository keeps its own backlog, epics, run history, and working directory. The workspace view preserves the larger picture without pretending that more charts equal more control.

02 / Define

Context stays attached to the work.

A Ripple story can hold Markdown, acceptance criteria, implementation constraints, an epic, status, and a complete event history. People and agents read the same artifact through the UI and API, so there is no second, quietly diverging version of reality.

Ripple story detail with description, acceptance criteria, and project constraints — A story carries enough context to be useful tomorrow, not just in the conversation that created it.

03 / Sequence

The backlog is not permission to run everything

Some changes unlock others. Some are safer alone. Ripple freezes the selected queue into a run so the execution plan cannot drift underneath the agents. Choosing what enters that run—and when—stays a human decision.

Ripple project backlog with selectable stories and an execution queue — Select the work, set the order, and review the queue before execution begins.

04 / Deliver

What happens after I press Start

Ripple is more than a task manager. Each queued story moves through a real delivery workflow, with independent review and visible quality gates instead of a single opaque agent pass.

01 / Implement

Codex creates a branch, works the story, commits the change, pushes it, and opens a pull request.

02 / Review

Grok provides an independent review. Actionable feedback returns to Codex for a focused fix pass.

03 / Verify

Ripple runs the project’s available tests, linting, type checks, and build before the work can advance.

04 / Merge

The GitHub CLI merges the pull request, while the transcript and final outcome remain attached to the run.

Completed Ripple run showing three stories, review output, pull requests, and elapsed time — Three stories completed, reviewed, and merged—with every agent pass and pull request preserved.

I wanted the automation to be genuinely useful without asking for blind trust. A successful run should be easy to understand. A failed run should be diagnosable. Both should leave a record.

API first

Agents can use Ripple directly, too.

An agent can start at GET /api, discover the workflow rules, inspect the OpenAPI contract, find a story, and report status through JSON endpoints. The API makes the system flexible; the workflow boundaries keep it legible.

Agents work with backlog, in-progress, and done stories. Queueing and closing remain human actions.

Ripple About page explaining its human and agent workflow — Ripple documents its workflow, local tools, and responsibility boundaries inside the product.

Local by design

One Go process. A database you own.

Ripple uses embedded SQLite, server-rendered HTML, HTMX, and plain CSS. There is no Node runtime, hosted database, container, or account required for Ripple itself. It runs beside the repositories and command-line agents it coordinates, keeping the backlog, run history, and transcripts on your machine.

Try Ripple

git clone https://github.com/adamaoc/ripple.git
cd ripple
go run .

# Open the local workspace
open http://localhost:8080

Go 1.24+

Ripple itself needs only Go and Git.

Agent CLIs

Autonomous runs use authenticated Codex and Grok installations.

GitHub CLI

The delivery loop creates and merges pull requests with gh.

The larger experiment

The interesting product space is not replacing the human. It is the system between human judgment and agent execution.

Context, sequencing, review, visibility, and trust: that is the space I built Ripple to explore.

Explore Ripple on GitHub

Meet Ripple: A Local-First Task Manager for Coding Agents · Open source under MIT