Open Source · MIT Licensed

# The dark software factory
for expert engineers

AI coding agents are powerful but unpredictable. Define your process as a graph, let agents execute it, and intervene only where it matters.

`$ curl -fsSL https://fabro.sh/install.md | claude`
`$ codex "$(curl -fsSL https://fabro.sh/install.md)"`
`$ curl -fsSL https://fabro.sh/install.sh | bash`
Get started View on GitHub

## Stop babysitting agents.
Start orchestrating workflows.

You either babysit every step or review a 50-file diff you don't trust. Fabro gives you a middle path: version-controlled workflow graphs that orchestrate AI agents, shell commands, and human decisions into repeatable, long-horizon coding processes.

## Key features

Workflow Engine

### Deterministic workflow graphs

Define pipelines in Graphviz DOT with branching, loops, parallelism, and human gates. Diffable, reviewable, version-controlled.

Control

### Human-in-the-loop

Approval gates pause for human decisions. Steer running agents mid-turn. Interview steps collect structured input.

Intelligence

### Multi-model routing

CSS-like stylesheets route each node to the right model and provider, with automatic fallback chains.

Isolation

### Cloud sandboxes

Run agents in isolated cloud VMs with snapshot-based setup, network controls, and automatic cleanup. SSH in with `fabro ssh`.

Versioning

### Git checkpointing

Every stage commits code changes and execution metadata to Git branches. Resume, revert, or trace any change.

Analytics

### Automatic retrospectives

Each run generates a retro with cost, duration, files touched, and an LLM-written narrative. Your workflows improve over time.

Interface

### API server + web UI

REST API with SSE event streaming and a React web UI. Run workflows programmatically or as a service. Queue runs, track progress, manage at scale.

Distribution

### Single binary, no runtime

One compiled Rust executable with zero dependencies. No Python, no Node, no Docker required.

## Workflow-as-Code

Define how work gets done in version-controlled graph files. Each node is a stage — agent, command, human gate, conditional — executed by the workflow engine.

- Agent nodes run multi-turn LLM sessions with tool access
- Human gates (`hexagon`) pause for approval or revision
- Parallel nodes fan out for concurrent execution, then merge
- Command nodes run shell scripts for builds, tests, and linters

plan-implement.fabro

    digraph PlanImplement {
      graph [
        goal="Plan, approve, implement, and simplify a change"
        model_stylesheet="
          *        { model: claude-haiku-4-5; }
          .coding  { model: claude-sonnet-4-5; }
        "
      ]

      start  [shape=Mdiamond, label="Start"]
      exit   [shape=Msquare, label="Exit"]

      plan      [label="Plan", prompt="Analyze the goal and codebase. Write a step-by-step plan."]
      approve   [shape=hexagon, label="Approve Plan"]
      implement [label="Implement", class="coding"]
      simplify  [label="Simplify", class="coding"]

      start -> plan -> approve
      approve -> implement  [label="Approve"]
      approve -> plan       [label="Revise"]
      implement -> simplify -> exit
    }

## Verification is a
first-class concept

Fabro doesn't just produce output — it validates it. Builds and tests are gates, not suggestions. Failures trigger automatic fix loops. Human gates let you approve, revise, or steer.

Mergeable results that survive CI and code review.

## Multi-model, multi-provider

CSS-like stylesheets assign models to workflow stages by ID, class, or shape. Use fast models for breadth, frontier models for correctness — with automatic fallback chains.

- Anthropic, OpenAI, and Gemini models out of the box
- Selector specificity: `#id` > `.class` > `shape` > `*`
- Ensemble strategies to maximize quality and minimize cost

models.css

    /* All nodes default to fast + cheap */
    * {
      model: claude-haiku-4-5;
      reasoning_effort: low;
    }

    /* Coding stages use a frontier model */
    .coding {
      model: claude-sonnet-4-5;
      reasoning_effort: high;
    }

    /* Cross-critique with a different provider */
    #review {
      model: gemini-3.1-pro-preview;
    }

## Ground-up observability

Full traceability across runs — every model call, every tool invocation, every decision point. Query run data with SQL. Automatic retrospectives rate each run and surface friction points.

fabro.workflow.run — trace
workflow
fabro.workflow.run — 24.3s
plan
4.1s
implement
12.7s
simplify
4.2s
retro
3.3s

## Workflows that compound.
Output you can trust.

→
Reviewable changes
Not massive diffs
→
Verification gates
Not vibes
→
Git checkpoints + audit trails
Not opaque agents
→
Repeatable workflows
Not one-off prompts
`$ curl -fsSL https://fabro.sh/install.md | claude`
`$ codex "$(curl -fsSL https://fabro.sh/install.md)"`
`$ curl -fsSL https://fabro.sh/install.sh | bash`
Get started View on GitHub