vibe-flow OSS launch
GitHub Run it

An 8‑agent autonomous product team that ships through a 10‑stage pipeline.

vibe-flow is a monorepo of OpenClaw extensions, skills, and quality tooling. It runs a full product team inside an AI gateway — taking ideas from chat to merged PRs.

8
agents
10
pipeline stages
5
extensions
Quick start Star on GitHub

No frameworks. No build step. Mermaid diagrams. System fonts.

Why developers care
  • Role clarity: PM → PO → TL → Design → Dev → QA → Review → Shipping.
  • Guarded state machine: transitions require evidence, not vibes.
  • Auditability: decisions, events, and outcomes are logged.
  • Composable architecture: 5 extensions, clean responsibility split.

Key features

What you get when you run vibe-flow with OpenClaw.

Evidence‑driven workflow

Stages advance only when required evidence is present (tests, lint, QA report, review result).

Safe tool surface

Each agent uses a strict allow‑list: tasks, workflow, quality, decisions, messaging, and pipeline tools.

Quality gate engine

Parse artifacts (Vitest/ESLint/coverage/complexity) and evaluate a policy with alerting + auto‑tuning.

Human‑supervised autonomy

Status updates route to chat so humans can supervise outcomes without micromanaging execution.

Docs

Start here if you’re evaluating or contributing.

In action

The 8-agent team running through a real pipeline.

OpenClaw dashboard showing the 8-agent roster with model routing
Agent roster & model routing
Pipeline status updates flowing through agent chat
Pipeline updates in chat
Quality gate summary with coverage, lint, and complexity results
Quality gate summary

Roadmap (high level)

A few near‑term milestones for the OSS launch.

  • Polish docs: contributor guide + examples of end‑to‑end runs.
  • More evidence types: performance budgets, RGR caps, and security checks.
  • Reliability: retry policies + partial failure handling.
  • Launch pack: demo script, screenshots, and a short explainer video.
Call to action
If you like the idea of a product team that can ship while you sleep, star the repo and follow along.
View on GitHub Run locally

Install / Quick start

Clone the repo and run with Docker. No web framework required.

Clone

Shell 
git clone https://github.com/Monkey-D-Luisi/vibe-flow
cd vibe-flow

Run (Docker)

Shell 
cp .env.docker.example .env.docker
# edit .env.docker
docker compose build
docker compose up -d

docker exec openclaw-product-team pnpm exec openclaw models list
docker exec openclaw-product-team pnpm exec openclaw doctor

Docs: docker-setup.md

What you get

  • Control UI: http://localhost:28789/
  • 8 agents + 5 plugins loaded
  • Chat integration for human oversight
  • Quality gate CLI for local/CI validation

The 10‑stage pipeline

A predictable assembly line: each stage produces evidence that unlocks the next.

Stages

  1. 1 IDEA
  2. 2 ROADMAP
  3. 3 REFINEMENT
  4. 4 DECOMPOSITION
  5. 5 DESIGN
  6. 6 IMPLEMENTATION
  7. 7 QA
  8. 8 REVIEW
  9. 9 SHIPPING
  10. 10 DONE

Each stage can post updates back to chat — so humans can supervise without micromanaging.

End‑to‑end flow

flowchart TD A[Human posts idea in chat] --> B["PM receives idea, creates roadmap item"] B --> C[PM breaks roadmap item into epics] C --> D[PO refines into user stories + acceptance criteria] D --> E[Tech Lead decomposes into technical tasks] E --> F[Designer creates designs] F --> G[Tech Lead assigns tasks to dev agents] G --> H["Devs implement (Backend & Frontend in parallel)"] H --> I[QA runs automated test suites] I --> J[Tech Lead reviews code] J --> K["DevOps creates PR, manages CI"]
Guarded transitions
The task lifecycle is a state machine. Some transitions are guarded and require metadata evidence.

Task state machine (transition guards)

stateDiagram-v2 backlog --> grooming grooming --> design grooming --> in_progress : fast-track (minor) design --> in_progress : requires architecture_plan in_progress --> in_review : requires dev_result in_review --> qa : requires review_result in_review --> in_progress : rejection loop qa --> done : requires qa_report qa --> in_progress : rework loop

Source: transition-guard-evidence.md

5 extensions, one cohesive runtime

This landing page is just static files — but the system behind it is modular and composable.

product-team

Task engine, workflow, quality, VCS automation, decision engine, pipeline orchestration.

quality-gate

Standalone quality engine + CLI for local and CI runs.

telegram-notifier

Lifecycle → chat notifications & routing.

model-router

Per-agent model routing via config + hooks.

stitch-bridge

Bridge to Google Stitch MCP for design tooling.

Integration topology

flowchart TD OC[OpenClaw Gateway] --> PT[product-team plugin] OC --> MR[model-router hook] OC --> TN[telegram-notifier] OC --> SB[stitch-bridge] PT --> T1[task.*] PT --> T2[workflow.*] PT --> T3[quality.*] PT --> T4[vcs.*] PT --> T5[team.* / decision.* / pipeline.* / project.*] PT --> DB[(SQLite DB + event log)] SB --> Stitch[Google Stitch MCP] CI[Local/CI shell] --> QG[quality-gate CLI]