Fabro is a workflow engine for AI coding agents. You define the process as a version-controlled graph, agents execute it, and you intervene at the points you chose rather than reviewing a large diff after the fact.
Workflows are written in the Graphviz DOT language, with branching, loops, parallelism, and human gates. Each node is a stage: agent nodes run multi-turn LLM sessions with tool access, command nodes run shell scripts for builds, tests, and linters, human gates pause for approval or revision, and parallel nodes fan out and merge. Because the graphs are plain files, they diff and review like any other source file.
Stylesheets written in CSS-like syntax route each node to a model and provider, with automatic fallback chains, so planning can run on a cheap model while coding runs on a frontier one. Verification is part of the graph too: test suites, linters, type checkers, and LLM-as-judge stages sit alongside the agent nodes, and a failure triggers a fix loop.
Runs can execute in isolated cloud virtual machines with snapshot-based setup, network controls, and automatic cleanup. You can open a shell into a running sandbox or expose one of its ports for live debugging.
Every stage commits code changes and execution metadata to Git branches, so a run can be resumed, reverted, or traced. Durable events, checkpoints, conclusions, and stage outputs make a finished run inspectable and exportable, and each run produces a retro covering cost, duration, and files touched.
Fabro runs as a server, either on your own machine or self-hosted from a Docker image, and exposes a REST API with server-sent event streaming alongside a React web interface for queueing and tracking runs. It is distributed as one compiled Rust executable that needs no Python, Node, or Docker runtime.
Features
- Workflow graphs: pipelines defined in Graphviz DOT with branching, loops, parallelism, and human gates
- Human-in-the-loop: approval gates pause a run, agents can be steered mid-turn, and interview steps collect structured input
- Multi-model routing: CSS-like stylesheets assign a model and provider per node, with automatic fallback chains
- Cloud sandboxes: agents run in isolated cloud virtual machines with snapshot setup, network controls, and automatic cleanup
- Sandbox access: fabro sandbox ssh opens a shell and fabro sandbox preview exposes a port on a running sandbox
- Git checkpointing: each stage commits code and execution metadata to a Git branch, so a run can be resumed, reverted, or traced
- Run observability: durable events, checkpoints, conclusions, and stage outputs are queryable and exportable
- Verification stages: deterministic checks and LLM-as-judge steps sit in the graph, and failures trigger fix loops automatically
- API and web interface: a REST API with server-sent event streaming plus a React web UI for running workflows as a service
- Single binary: one compiled Rust executable with no Python, Node, or Docker requirement
- Build provenance: release binaries and the multi-arch Docker image ship with SLSA build provenance attestations

