Fabro

AI-first language that frames the coding-agent harness as a graph-execution problem.

Website | Source

Workflow harness for coding agents. .fabro files are Graphviz digraphs whose node shapes pick handlers; a CSS-like stylesheet routes each step to a model. Single Rust binary.

Camp: Orchestration
Author: Bryan Helmkamp (Qlty Software)
Implementation language: Rust
Compilation target: Native binary (Rust workspace, embedded React SPA)
Licence: MIT
First seen: March 2026
Maturity: working compiler

Agent tooling:
- AGENTS.md (CLAUDE.md as symlink)
- Agent Skills format (~/.fabro/skills/, project skills/)
- MCP server with 7 fabro_run_* tools
- install.md (agent-targeted installer prompt)
- fabro graph (renders DOT workflows to SVG)

Key idea

Fabro frames the coding-agent harness as a graph-execution problem. A workflow is a .fabro file containing a Graphviz digraph; Graphviz shapes map directly to handler types (Mdiamond start, Msquare exit, box agent step, parallelogram shell command, diamond conditional, hexagon human gate, component parallel fan-out). Edge labels carry a condition grammar (=, !=, >, <, contains, matches, &&, ||, !). A second authored notation -- a CSS-like model_stylesheet -- assigns model, provider, and reasoning_effort per node by selector (* < shape < .class < #id). The runtime ships as a single Rust binary that checkpoints to git between stages and runs agent steps in local, Docker, SSH, or Daytona sandboxes.

Thesis

Fabro starts from the observation that agent coding harnesses spend most of their time in two failure modes: either a human babysits each step in a REPL, or the agent returns a 50-file diff and the human has to reconstruct what happened. Fabro's diagnosis is that this is what you get when the harness has no authored artefact to point at. The fix is to make the process itself a source file. A .fabro workflow is a Graphviz digraph; the agent runs through it node by node; the file is diffable, reviewable, and version-controlled like any other code. Fabro lifts the term "dark software factory" from Dan Shapiro's January 2026 five-levels framework and commits to it as the project's framing: humans supervise specs, guardrails, and outcomes; the factory handles the steps in between.

Define the process as a graph, let agents execute it, and intervene only where it matters.

The distinctive move sits at the file level: every .fabro workflow is a Graphviz DOT digraph, and the Graphviz shape is the handler type. Mdiamond is the start node, Msquare is the exit, box is an agent step that runs a multi-turn LLM session with tool access, parallelogram is a shell command, hexagon is a human gate that pauses for approval, diamond is a conditional, and component is a parallel fan-out. Edges carry labels and a condition grammar (=, !=, >, <, contains, matches, &&, ||, !) that reads against an Outcome and the run's shared context. A second authored notation, the model_stylesheet, is a CSS-like file that assigns model, provider, and reasoning_effort to nodes by selector with documented specificity (* zero, shape one, .class two, #id three). Where Boruna gates declared effects at the bytecode VM and chains them into evidence bundles, Fabro gates execution at the graph edge and commits the git checkpoint only after a stage succeeds.

What it looks like

digraph PlanImplement {
    graph [
        goal="Plan, approve, implement"
        model_stylesheet="
            *        { model: claude-haiku-4-5; }
            .coding  { model: claude-sonnet-4-5;
                       reasoning_effort: high; }
            #review  { model: gpt-5.2; }
        "
    ]
    // nodes: the shape attribute selects the handler
    start     [shape=Mdiamond, label="Start"]
    exit      [shape=Msquare,  label="Exit"]
    plan      [label="Plan", prompt="Write a plan."]
    approve   [shape=hexagon, label="Approve Plan"]
    implement [label="Implement", class="coding"]
    review    [label="Review", class="coding"]
    // edges: labels are options at gates; conditions gate flow
    start -> plan -> approve
    approve -> implement [label="[A] Approve",
                          condition="outcome=succeeded"]
    approve -> plan      [label="[R] Revise"]
    implement -> review -> exit
}

A four-stage workflow with a human gate. hexagon nodes pause for input; outgoing-edge labels become the selectable options ([A] and [R] are accelerator keys). The stylesheet routes the cheap default model to most nodes and reserves Sonnet for the coding stages.

Distinctive moves

Maturity

The workspace is 47 Rust crates and roughly 392k lines of code, with 96 release tags (most nightlies) and a daily changelog that runs from late February through mid-June 2026 at the time of cataloguing. The repository reports 1,221 stars and 133 forks; the GitHub contributors list shows sixteen names, of which Bryan Helmkamp authored 3,624 of 3,840 commits and three release bot accounts contributed roughly 5 percent of the remaining traffic. The LICENSE is MIT and the copyright is held by Qlty Software Inc., Helmkamp's company; the project is hosted under its own fabro-sh GitHub organisation rather than qltysh. Three observations the editorial frame should surface honestly. First, documentation polish runs ahead of demonstrable adoption: the marketing site, full OpenAPI spec, embedded web UI, and feature breadth are unusual for a project four months from first public push. Second, an evals/swe-bench directory in the repo ships a self-published SWE-Bench-Lite scoreboard (GPT-5.4 at 65.7% resolve rate over 300 instances; Sonnet 4.6 at 57.7%; Haiku 4.5 baseline at 54.0%); no third-party reproduction has yet been published. Third, the graph-based-process pattern itself is not novel — LangGraph and other harnesses have been there. Fabro's specific bet is on .fabro-as-DOT-file plus CSS-stylesheet model routing plus single-Rust-binary delivery as a combination, rather than on the graph idea in isolation.

The bet is that "expert engineers running small teams" -- explicitly the target in the docs and tagline -- will accept a structured workflow file as the price of disengagement time, and that the dark-factory framing will pull verification and human-in-the-loop into the same surface that defines the agent steps.

Agent tooling

The agent-facing surface is unusually broad. AGENTS.md (with CLAUDE.md symlinked to it) is 17 KB and orients agents working in the repository. Fabro implements the open Agent Skills format, discovering SKILL.md files from ~/.fabro/skills/, {git_root}/.fabro/skills/, and {git_root}/skills/; skills are exposed both as a /skill-name slash syntax and a use_skill tool added to every agent step. An earlier fabro skill install command bundled a fabro-create-workflow skill for Claude Code and Codex; that command was removed in April 2026 when skills moved to user-supplied directories. The CLI's fabro mcp init configures Claude Code, Cursor, or Windsurf to launch Fabro as an MCP server exposing seven run-management tools (fabro_run_create, _search, _get, _interact, _gather, _pair, _events); a workflow can also opt agent steps into the same tool catalogue with [run.agent] fabro_tools = true to spawn structured child runs. fabro graph renders any workflow to SVG. The installer itself is agent-targeted: piping https://fabro.sh/install.md into Claude Code or Codex runs an objective-and-steps prompt that drives the install, the wizard, and the server restart end-to-end.

Design DNA

Timeline

Tags: language   ai   orchestration   native  

Last modified 21 June 2026