Fabro.

The 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
}

Distinctive moves.

• Shape-as-handler. The Graphviz shape attribute on a node selects the handler. box is an agent; parallelogram runs a script; hexagon is a human gate; component fans out. The DOT file is not a transport; it is the source language.
• Model stylesheet as second notation. Routing a node to a different model, provider, or reasoning effort is a CSS rule, not a configuration change. * (universal) yields to shape, which yields to .class, which yields to #id. Explicit per-node attributes win over any rule.
• Git checkpointing between stages. Each stage commits its execution state, prompts, responses, and file changes to a meta branch (fabro/meta/*). Resume, revert, and fork from any point use git as the durable store.
• Single Rust binary. A 47-crate workspace compiles to one executable with an embedded React SPA. No Python, Node, or Docker is required to run the binary itself; Docker, SSH, and Daytona are optional sandbox providers for the agent steps it launches.
• Plan-implement-verify as a graph primitive. Conditional edges, retry policies on nodes, goal_gate=true attributes, and wait_all / first_success parallel-join policies turn LLM-as-judge and lint-driven fix loops into a few extra nodes rather than harness plumbing.
• MCP both ways. Fabro consumes MCP tool servers for agent steps and exposes itself as an MCP server with seven fabro_run_* tools (create, search, get, interact, gather, pair, events) so coding agents can drive runs from inside another harness.

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.