Fabro Workflow Factory

Fabro Workflow Factory

Skill by ara.so — Daily 2026 Skills collection.

Fabro is an open source AI coding workflow orchestrator written in Rust. It lets you define agent pipelines as Graphviz DOT graphs — with branching, loops, human approval gates, multi-model routing, and cloud sandbox execution — then run them as a persistent service. You define the process; agents execute it; you intervene only where it matters.

Installation

# Via Claude Code (recommended)
curl -fsSL https://fabro.sh/install.md | claude

# Via Codex
codex "$(curl -fsSL https://fabro.sh/install.md)"

# Via Bash
curl -fsSL https://fabro.sh/install.sh | bash

After installation, run one-time setup and per-project initialization:

fabro install      # global one-time setup
cd my-project
fabro init         # per-project setup (creates .fabro/ config)

Key CLI Commands

# Workflow management
fabro run <workflow.dot>          # execute a workflow
fabro run <workflow.dot> --watch  # stream live output
fabro runs                        # list all runs
fabro runs show <run-id>          # inspect a specific run

# Human-in-the-loop
fabro approve <run-id>            # approve a pending gate
fabro reject <run-id>             # reject / revise a pending gate

# Sandbox access
fabro ssh <run-id>                # shell into a running sandbox
fabro preview <run-id> <port>     # expose a sandbox port locally

# Retrospectives
fabro retro <run-id>              # view run retrospective (cost, duration, narrative)

# Config
fabro config                      # view current configuration
fabro config set <key> <value>    # set a config value

Workflow Definition (Graphviz DOT)

Workflows are .dot files using the Graphviz DOT language with Fabro-specific attributes.

Node Types

Minimal Hello World

// hello.dot
digraph HelloWorld {
    graph [
        goal="Say hello and write a greeting file"
        model_stylesheet="
            * { model: claude-haiku-4-5; }
        "
    ]

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

    greet [label="Greet", prompt="Write a friendly greeting to hello.txt"]

    start -> greet -> exit
}

fabro run hello.dot

Multi-Model Routing with Stylesheets

Fabro uses CSS-like model_stylesheet declarations on the graph to route nodes to models. Use classes to target groups of nodes.

digraph PlanImplementReview {
    graph [
        goal="Plan, implement, and review a feature"
        model_stylesheet="
            *          { model: claude-haiku-4-5; reasoning_effort: low; }
            .planning  { model: claude-opus-4-5;  reasoning_effort: high; }
            .coding    { model: claude-sonnet-4-5; reasoning_effort: high; }
            .review    { model: gpt-4o; }
        "
    ]

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

    plan     [label="Plan",      class="planning", prompt="Analyze the codebase and write plan.md"]
    implement [label="Implement", class="coding",   prompt="Read plan.md and implement every step"]
    review   [label="Review",    class="review",   prompt="Cross-review the implementation for bugs and clarity"]

    start -> plan -> implement -> review -> exit
}

Supported Model Stylesheet Properties

model: <model-id>           # e.g. claude-sonnet-4-5, gpt-4o, gemini-2-flash
reasoning_effort: low|medium|high
provider: anthropic|openai|google

Human Gates (Approval Nodes)

Use shape=hexagon to pause execution for human approval. Transitions are labeled with [A] (approve) and [R] (revise/reject).

digraph PlanApproveImplement {
    graph [
        goal="Plan and implement with human approval"
        model_stylesheet="
            * { model: claude-sonnet-4-5; }
        "
    ]

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

    plan    [label="Plan",         prompt="Write a detailed implementation plan to plan.md"]
    approve [shape=hexagon,        label="Approve Plan"]
    implement [label="Implement",  prompt="Read plan.md and implement every step exactly"]

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

Approve or reject from the CLI:

fabro runs                          # find the paused run-id
fabro approve <run-id>              # continue with implementation
fabro reject <run-id> --note "Add error handling to the plan"

Loops and Fix Cycles

Use labeled transitions to build automatic retry/fix loops:

digraph ImplementAndTest {
    graph [
        goal="Implement a feature and fix failing tests automatically"
        model_stylesheet="
            *       { model: claude-haiku-4-5; }
            .coding { model: claude-sonnet-4-5; reasoning_effort: high; }
        "
    ]

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

    implement [label="Implement", class="coding",
               prompt="Implement the feature described in TASK.md"]
    test      [label="Run Tests",
               prompt="Run the test suite with `cargo test`. Report pass/fail."]
    fix       [label="Fix",       class="coding",
               prompt="Read the test failures and fix the code. Do not change tests."]

    start -> implement -> test
    test -> exit [label="[P] Pass"]
    test -> fix  [label="[F] Fail"]
    fix  -> test
}

Parallel Nodes

Run multiple agent nodes concurrently by forking edges from a single source:

digraph ParallelReview {
    graph [
        goal="Implement then review from multiple perspectives in parallel"
        model_stylesheet="
            *         { model: claude-haiku-4-5; }
            .coding   { model: claude-sonnet-4-5; }
            .critique { model: gpt-4o; }
        "
    ]

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

    implement [label="Implement",      class="coding",
               prompt="Implement the task in TASK.md"]
    sec_review  [label="Security Review",  class="critique",
                 prompt="Review the implementation for security issues"]
    perf_review [label="Perf Review",      class="critique",
                 prompt="Review the implementation for performance issues"]
    summarize   [label="Summarize",
                 prompt="Combine the security and performance reviews into REVIEW.md"]

    start -> implement
    implement -> sec_review
    implement -> perf_review
    sec_review  -> summarize
    perf_review -> summarize
    summarize -> exit
}

Variables and Dynamic Prompts

Use {variable} interpolation in prompts. Pass variables at run time:

digraph FeatureWorkflow {
    graph [
        goal="Implement {feature_name} from the spec"
        model_stylesheet="* { model: claude-sonnet-4-5; }"
    ]

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

    implement [label="Implement {feature_name}",
               prompt="Read specs/{feature_name}.md and implement the feature completely."]

    start -> implement -> exit
}

fabro run feature.dot --var feature_name=oauth-login

Cloud Sandboxes (Daytona)

To run agents in isolated cloud VMs instead of locally, configure a Daytona sandbox:

fabro config set sandbox.provider daytona
fabro config set sandbox.api_key $DAYTONA_API_KEY
fabro config set sandbox.region us-east-1

Then add sandbox config to your workflow graph:

digraph SandboxedWorkflow {
    graph [
        goal="Implement and test in an isolated environment"
        sandbox="daytona"