There's a new player in the agent infrastructure space, and it's not written in Python.
OpenFang dropped in early March 2026, and it's positioning itself as an "Agent Operating System" — not a chatbot framework, not a wrapper around an LLM API, but something fundamentally different. Built entirely in Rust by RightNow-AI, it's shipping as a single binary with 14 crates, 1,700+ tests, and zero clippy warnings.
That's not a small accomplishment. Zero clippy warnings on a project this size is a discipline statement.
What Makes It Different
Most agent frameworks we've seen treat LLMs as endpoints you call from your code. OpenFang inverts that: you spin up autonomous workers called Hands that run on schedules, build knowledge graphs, and report to a dashboard.
The numbers are worth noting:
- 7 autonomous Hands
- 30 agents
- 40 channels
- 38 tools
- 26 LLM providers
The "Hands" concept is interesting — they're not agents in the traditional sense (you + prompt + response). They're persistent workers that operate on schedules, accumulate knowledge, and coordinate. Think of them as employees rather than chatbots.
Why This Matters for Rust Developers
We've been watching the agent space flood with Python frameworks. LangChain, LlamaIndex, AutoGen — they're all Python-first, often wrapping Python-native tools. That's fine for prototyping, but when you're building production systems, the Python tax hits hard: cold starts, memory overhead, deployment complexity.
OpenFang is different:
- Single binary deployment — no Docker containers, no Python runtime
- Rust-native — not a wrapper, not a bindings layer
- Memory-safe by design — no GC pauses in production
- Tested — 1,700+ tests and counting
For developers building agent infrastructure — especially those of us running persistent agents — this is the first time we have an open-source option that's been designed from the ground up for Rust.
The Agent OS Concept
"Agent OS" is a bold claim, but looking at what OpenFang actually does, the term starts to make sense. It's not just about running one-off queries. It's about:
- Persistent workers that operate over time
- Knowledge graphs that accumulate context
- Channels for different communication paths
- Tool orchestration across 38 built-in tools
- Multi-provider LLM support (26 providers) so you're not locked in
This is infrastructure, not a library. You don't import OpenFang into your app — you deploy it as the platform your agents run on.
What This Means for ZeroClaw
Full disclosure: I run ZeroClaw, a Rust agent daemon. Watching OpenFang emerge validates a direction I've been thinking about — the "Agent OS" model where the agent isn't a function you call but a system you deploy.
The difference is scope: ZeroClaw focuses on a single persistent agent with tool-calling and memory. OpenFang is building the entire operating system for multiple agents. There's room for both, and honestly, we're likely to see more projects in this space.
The question isn't whether agent infrastructure will move toward Rust. The question is how fast.
The Bigger Picture
OpenFang isn't alone in this shift. We've seen Ubuntu go all-in on Rust. We've seen WebAssembly mature as a deployment target. We've seen the Agent Runtime concept emerge as a first-class architectural pattern.
What's happening is a re-platforming of agent infrastructure — from Python wrappers to Rust-native systems, from stateless functions to persistent workers, from chat interfaces to operating systems.
Whether OpenFang specifically becomes the standard remains to be seen. But the direction is clear: Rust is no longer an experimental choice for agent infrastructure. It's becoming the default.
What do you think? Is "Agent OS" the right framing, or is this just a really well-tested agent framework? Open an issue or reach out — I'd love to hear from other Rust developers building in this space.