Define AI agent workflows as code graphs, route tasks across any LLM, and intervene only where it matters.
Fabro is an open source AI workflow orchestration platform built for engineers who want control over their AI coding agents without babysitting every step. Rather than watching an agent REPL or reviewing an opaque 50-file diff, Fabro lets you define the process as a Graphviz DOT graph — with branching, loops, parallelism, and human approval gates — and then executes that graph using LLM agents as the compute layer.
At its core, Fabro separates workflow definition from execution: you write a .fabro graph file describing stages (plan, implement, verify, simplify) and transitions, while Fabro’s Rust-based server handles the state machine, checkpointing every stage to Git branches, streaming events over SSE, and exposing the full run history via a REST API and React web UI.
Fabro’s multi-model routing is a key differentiator. A CSS-like stylesheet attached to the graph controls which model handles each node — route cheap tasks to fast, inexpensive models and reserve frontier models for implementation. This makes it practical to run ensemble workflows where one model generates, another critiques, and a third summarizes, all within a single graph definition.
The entire stack ships as a single Rust binary with zero runtime dependencies — no Python, no Node required to run the server. Workflows can execute locally, in Daytona cloud sandboxes with full network and filesystem isolation, or be self-hosted via Docker on any cloud container platform. All artifacts are SLSA Build Provenance attested.
.fabro graph files in the monorepoArchitecture
Fabro uses a modular Rust workspace with around 40 crates organized into well-defined layers. The fabro-core crate defines the abstract execution engine: Graph, NodeSpec, EdgeSpec, and Executor traits that are completely decoupled from any LLM or workflow format. The fabro-graphviz crate implements a Graphviz DOT parser and stylesheet system, producing concrete graphs consumed by fabro-cli and fabro-server. The fabro-agent crate runs multi-turn LLM sessions as node handlers while fabro-workflow wires stage timing extraction and event projection. The fabro-server crate exposes an Axum-based REST API with SSE event streaming, while fabro-store persists run state to SlateDB backed by S3-compatible object storage. The fabro-sandbox crate abstracts local and Daytona cloud execution environments. This layered design means the core executor is testable in isolation, the DOT parser is independent of the agent runtime, and the server can be deployed without the local CLI’s sandbox features.
Tech Stack
Fabro is entirely written in Rust using the Tokio async runtime. The HTTP layer uses Axum with SSE streaming via sse-stream. Persistence combines SlateDB (an LSM-tree embedded database) with object_store for S3-compatible artifact storage. The fabro-llm crate implements provider adapters for Anthropic, OpenAI, Gemini, AWS Bedrock (using native aws-sigv4 request signing without the full SDK), and a generic OpenAI-compatible endpoint. Git checkpointing uses git2 with vendored libgit2 and OpenSSL. Cloud sandbox orchestration uses the Daytona SDK via a vendored Rust client. The web frontend in apps/fabro-web is a React application built with Bun. The DOT graph stylesheet uses a CSS-inspired mini-language parsed in fabro-graphviz. Templating uses minijinja, diagnostics use miette with full terminal-friendly error rendering, and structured tracing uses the tracing ecosystem with optional Sentry integration.
Code Quality
The Rust workspace enforces strict quality standards: unsafe_code = deny workspace-wide, unwrap_used = deny (with a pedantic clippy profile requiring exhaustive match), and unreachable_pub = warn. The CI pipeline runs cargo fmt, cargo clippy -- -D warnings, and cargo test --workspace. The test infrastructure includes a fabro-test helper crate, twin API servers for OpenAI and GitHub (realistic HTTP stubs), and a test/ directory with graph fixtures for branching, parallelism, and template scenarios. Inline comment density is comprehensive in core crates — the Cargo.toml workspace dependencies include detailed rationale comments explaining non-obvious choices. The insta snapshot testing crate is included for output regression tests.
What Makes It Unique
Fabro’s most distinctive technical choice is modeling AI agent processes as a formal directed graph (Graphviz DOT) rather than as imperative code or drag-and-drop flowcharts. This makes workflow definitions diffable, reviewable in PRs, and composable via standard graph tooling. The CSS-like model stylesheet — where * { model: claude-haiku-4-5 } sets a default and .coding { model: claude-sonnet-4-5 } overrides a class — is a genuinely novel approach to multi-model routing that requires no code changes to switch providers. The combination of Git-native checkpointing (every stage commits to a branch) with durable SSE event streams and SlateDB persistence gives Fabro strong resumability guarantees — a property most agent frameworks lack entirely.
Licensing Model MIT licensed — all features available in self-hosted deployments with no restrictions or license keys required.
Self-Hosting Fabro ships a multi-arch Docker image with SLSA Build Provenance attestations. Docker Compose configurations are included for local, production, and split-web deployments. One-click Railway deployment is provided. No feature gating between self-hosted and managed.
No Code Platforms · AI Development · Developer Tools
Visual LLM workflow platform with RAG pipelines, agent capabilities, and model management for building production AI applications.
Developer Tools · Game Development · Design Tools
Free, MIT-licensed 2D and 3D game engine with one-click multi-platform export and no royalties.
Developer Tools · Databases · Search
The open-source Postgres development platform that replaces Firebase with authentication, real-time APIs, edge functions, storage, and vector embeddings — all built on PostgreSQL.