OpenFang

OpenFang frames itself less as an agent framework and more as an operating system for agents — a persistent kernel process that manages agent memory, skills, extensions, and communication channels, rather than a library you import into a script that exits when the task is done. It compiles to a single binary from roughly 137,000 lines of Rust across 14 crates.

The crate layout mirrors an OS-like design: openfang-kernel is the core process, openfang-runtime executes agent logic, openfang-memory persists agent state, openfang-skills and openfang-extensions add capabilities, openfang-channels and openfang-wire handle communication protocols and multi-channel input/output, and openfang-hands appears to handle tool/action execution. Separate CLI and desktop crates, plus an SDK, provide different ways to interact with the running kernel.

Dual-licensed under Apache-2.0 or MIT (standard for Rust projects), OpenFang is explicitly pre-1.0 (“feature complete but still pre-1.0… expect rough edges”) as of its most recent documented version, so it’s an actively evolving project rather than a mature, stable-API tool.

What You Get

• A persistent agent kernel process rather than a run-once script, with dedicated crates for runtime, memory, and skills
• Multi-channel communication support (openfang-channels, openfang-wire) for connecting agents to different input/output surfaces
• CLI, desktop app, and SDK crates for interacting with the running kernel in different contexts
• An extension system (openfang-extensions) for adding capabilities without modifying the kernel itself

Common Use Cases

• Running long-lived AI agents that need persistent memory and state across sessions, not just single request/response calls
• Building agents that need to communicate across multiple channels (CLI, desktop, API) from one underlying kernel
• Extending agent capabilities through a skills/extensions system instead of hardcoding new behavior into the core
• Self-hosting an agent runtime as a single Rust binary instead of a Python-based framework with heavier dependencies

Under The Hood

Architecture OpenFang’s 14-crate layout is explicitly OS-inspired: openfang-kernel is the persistent core process, openfang-runtime executes agent logic against it, openfang-memory handles state persistence, openfang-skills/openfang-extensions add capabilities as pluggable units, and openfang-channels/openfang-wire manage how the kernel communicates with the outside world across multiple surfaces. openfang-cli and openfang-desktop are separate front-ends to the same kernel, and a dedicated sdk/ lets external code integrate with a running instance — the kernel is the persistent source of truth, and every other crate is a client or capability layered on top of it.

Tech Stack Rust throughout (137K LOC across 14 crates), compiled to a single binary, with Docker and Docker Compose support for deployment, a Nix flake for reproducible builds, and cross-compilation tooling (Cross.toml) for multiple targets.

Code Quality The README reports 1,767+ (and per badges, 2,696+) passing tests and zero Clippy warnings — an unusually explicit quality bar for a pre-1.0 project, and a strong signal of engineering discipline given Rust’s Clippy linter catches a wide range of correctness and style issues.

What Makes It Unique Most agent frameworks are libraries invoked per-task; OpenFang’s kernel-based, OS-like architecture treats the agent process as a persistent system service with memory, skills, and multi-channel I/O as first-class kernel concerns — a structurally different bet than typical Python agent frameworks, backed by an unusually rigorous automated test suite for a project this early.

Self-Hosting

Licensing Model Dual-licensed under Apache-2.0 or MIT (standard for Rust projects) — fully open source with no license key.

Self-Hosting Restrictions None found; OpenFang runs as a self-contained binary with no external licensing service.

License Key Required No.