Ripline

🔗

Explicit Step Boundaries

Each workflow step is declared in YAML or JSON with clear edges, inputs, and outputs.

⚡

Repeatable Runs

Pipelines live as files, runs are persisted, and failed workflows can be retried without rebuilding the whole process by hand.

🤖

Context Isolation

Agent nodes start with fresh context by default, so one step does not silently contaminate the next.

🔍

Runtime Contracts

Validate pipeline and node boundaries with JSON Schema so bad payloads fail at the edge instead of leaking downstream.

🔌

CLI, API, or OpenClaw

Run Ripline from the terminal, trigger it over HTTP, or host it inside OpenClaw when that integration fits your setup.

📋

Flexible Runners

Use LLM providers, Claude Code, Codex, or a custom runner per workflow step.

Problems Ripline solves

Multi-step agent workflows break down without structure. Ripline gives you that structure so you can run the same flow again, control cost and context, and see exactly what happened.

Repeatability

Same pipeline, same inputs → same path. Pipelines are versioned YAML/JSON, so you can rerun a flow exactly, share it with the team, or hand it to automation. No “it worked in my thread” drift.

Context isolation

Each step gets only the payload it needs. No giant chat history or mixed context. Downstream steps see typed outputs from upstream, so prompts stay focused and tokens stay under control.

Token & model control

Use a big model where you need reasoning and a smaller one for fast, mechanical steps. Set per-node model (e.g. Sonnet for spec, Haiku for implementation) and timeouts so cost and latency are predictable.

Contracts between steps

Define JSON Schema for inputs and outputs on nodes. Ripline validates at runtime so a step never receives the wrong shape. Catch mismatches before they hit the model or your scripts.

Traceability

Every run is logged: which node ran, what went in and out, duration, retries. When something fails, you see the exact step and payload. Resume from that node instead of starting over.

Example: Spec → Build → Queue

One concrete flow: turn a feature idea into a spec, break it into implementation stories, run each story in a focused step, then verify with build and tests. Same pipeline runs with OpenClaw (inside the host) or Claude Code (standalone).

Flow

Intake — One input: the feature or idea (e.g. “Add a weekly digest email”).
Spec — Agent writes a clear user-flow and design spec (Sonnet).
Decompose — Agent breaks the spec into small, atomic implementation stories (Sonnet).
Queue — Output a JSON array of tasks (id, title, detail).
Implement — Fan-out: one child run per story, each in a dedicated pipeline (e.g. Haiku, execute mode, fixed cwd).
Collect & verify — After all stories finish, one agent step runs build and tests and summarizes results (Sonnet).

Implementation

With OpenClaw: Load Ripline as a plugin. Agent nodes use the host’s runner (no runner field). Set projectRoot and other inputs via a profile. Run from the OpenClaw UI or CLI; pipelines live in the workspace.
With Claude Code (standalone): Use runner: claude-code and per-node model (e.g. claude-sonnet-4-6 for spec/decompose/verify, claude-haiku-4-5 for implement). Configure cwd via profile or run inputs. Run with ripline run or the HTTP API.

Spec → Build → Queue pipeline, example pipelines, Agent integration (OpenClaw & Claude Code).

Open source & free

Ripline is open source and free to use. The codebase is on GitHub — we welcome issues, pull requests, and ideas for runners, node types, and integrations.

If you’re building multi-step agent workflows and care about repeatability, contracts, and traceability, we’d love to hear from you. Open an issue or discussion to collaborate.

RiplineRepeatable agent workflows