OpenFang: The Open-Source Agent OS Built in Rust That Actually Works While You Sleep

The Problem With Every Agent Framework You've Tried

Here's a pattern every AI developer knows. You install a framework, write a system prompt, wire up some tools, run the agent — and then you sit there. Typing. Waiting. Typing again. The agent doesn't do anything unless you're driving it.

That's not autonomy. That's an expensive autocomplete with a fancy API wrapper.

Jaber, the founder of RightNow AI, hit this wall repeatedly. Every framework he tried — LangGraph, CrewAI, AutoGen, and others — was designed around conversation, not independence. They were built to respond, not to act. Autonomy was an afterthought, usually bolted on as a loop that kept asking the LLM what to do next until you told it to stop.

So he built something from scratch. He called it OpenFang — and it just launched on Product Hunt, landing as the #3 product of the day.

What OpenFang Actually Is

OpenFang describes itself as an Agent Operating System, and that label is deliberate. This is not a framework. Frameworks give you building blocks and expect you to assemble the rest. An OS gives you a complete runtime — scheduling, memory, security, communication, tooling — all working together as a coherent system.

The numbers give you a sense of scale: 137,000 lines of Rust across 14 modular crates. 1,700+ tests. Zero clippy warnings. 7 autonomous Hands. 16 security systems. 30 pre-built agents. 38 built-in tools plus full Model Context Protocol support. 40 channel adapters. 27 LLM providers. A native Tauri 2.0 desktop app. A 140+ endpoint REST API. All of it ships as a single binary, installed with one curl command:

curl -fsSL https://openfang.sh/install | sh

That last part matters more than it sounds. There's no npm dependency hell, no Python virtualenv conflicts, no Docker Compose file managing a dozen services. You run one command and you have a full Agent OS on your machine.

The Core Philosophy: Agents That Work For You

The defining idea in OpenFang is what Jaber calls the inversion. Traditional agents wait for you to drive them. OpenFang Hands work for you while you're not watching.

A Hand is a pre-built autonomous capability package — not a demo or a proof of concept, but a production-grade agent with its own schedule, its own operational playbook, its own dashboard metrics, and its own SKILL.md expert knowledge file. Each Hand is compiled directly into the binary at build time, not loaded dynamically at runtime. You activate a Hand, configure it, and check your dashboard. The work happens without you.

OpenFang ships with seven Hands out of the box:

Clip is a content production pipeline for video. It takes long-form video, processes it through an 8-phase pipeline using FFmpeg and yt-dlp with five speech-to-text backend options, generates captions and thumbnails, optionally adds AI voiceovers, and publishes finished clips to Telegram and WhatsApp automatically.

Lead is a full autonomous lead generation engine. It runs on a daily schedule, discovering new prospects through web research loops, enriching them with additional data, scoring them on a 0-to-100 ICP (Ideal Customer Profile) scale, deduplicating the results, and exporting clean lists in CSV, JSON, or Markdown. You wake up to a fresh, scored lead list every morning.

Collector is an OSINT-style intelligence monitor. Point it at any target — a competitor, an industry topic, a company, a person — and it watches continuously, detecting changes, performing sentiment analysis, building a knowledge graph over time, and firing critical alerts when something significant happens.

Predictor is a superforecasting engine. It collects signals from multiple sources, builds calibrated reasoning chains, makes explicit predictions, and tracks its own accuracy using Brier scores. It has a contrarian mode that deliberately challenges its own prior conclusions to guard against overconfidence.

Researcher goes well beyond web search. It applies the CRAAP evaluation methodology — checking Currency, Relevance, Authority, Accuracy, and Purpose — to cross-reference sources and fact-check claims. It generates fully cited reports in multiple languages with APA-format citations and source verification logs.

Twitter manages a social media presence end-to-end. It creates content in seven rotating formats, runs posts through an approval queue before publishing, engages with mentions, and tracks performance metrics over time — all while maintaining the brand voice you configure.

Browser handles complex web automation through a Playwright bridge. It navigates sites, fills forms, clicks buttons, and completes multi-step workflows including session persistence and CAPTCHA detection. Critically, it has a mandatory purchase approval gate — if an automated workflow would result in spending money, it stops and waits for explicit human authorization before proceeding.

Beyond these seven, developers can build and publish their own Hands using a HAND.toml manifest format, with the FangHub marketplace planned as the distribution layer.

Security That Is Architecture, Not a Feature

This is where OpenFang diverges most sharply from its competitors.

Most agent frameworks treat security as a configuration option. A setting you toggle on. A Docker container you run your agent inside. OpenFang builds security as a structural property of the runtime — 16 discrete systems that are not optional and cannot be bypassed.

The WASM dual-metered sandbox is the foundation. Every piece of tool code runs inside WebAssembly with two independent limits: fuel metering (measuring computational work) and epoch interruption (measuring wall-clock time). If a tool runs too long or does too much work, the OS terminates it. File operations are confined to a workspace directory — tools cannot reach outside their sandbox. Subprocesses are environment-cleared before execution and timeout-enforced.

Ed25519 manifest signing ensures that every Hand and every agent configuration has a cryptographic signature that can be verified at load time. Tampered manifests are rejected before they run.

The Merkle audit trail records every action an agent takes as a node in a cryptographically linked chain. Each record is tamper-evident: changing a prior entry breaks the chain's integrity, making it detectable. This gives operators a verifiable, reconstructible history of what their agents actually did — essential for compliance, debugging, and incident response.

Taint tracking marks sensitive data and prevents it from crossing agent boundaries or appearing in logs. SSRF protection blocks agents from being used to probe internal networks or services. A prompt injection scanner detects adversarial inputs designed to hijack agent behavior. Secret zeroization clears credentials from memory after use rather than letting them persist. A GCRA rate limiter enforces per-channel and per-provider rate limits. Subprocess isolation ensures spawned processes cannot inherit the parent's environment or escalate privileges. Path traversal prevention stops agents from escaping their workspace via directory traversal attacks.

To put this in context: CrewAI has 1 security layer. AutoGen and LangGraph each have 2. ZeroClaw has 6. OpenFang has 16. That gap represents a fundamentally different security posture — one designed for agents that operate on production systems with real data, real credentials, and real consequences.

How It Performs Against the Competition

OpenFang's website publishes benchmarks across six frameworks — OpenFang, OpenClaw, ZeroClaw, CrewAI, AutoGen, and LangGraph — covering cold start time, idle memory usage, install size, security depth, channel coverage, and LLM provider support.

On cold start time, OpenFang boots in 180ms, faster than LangGraph (2,500ms), CrewAI (3,000ms), AutoGen (4,000ms), and OpenClaw (5,980ms). ZeroClaw leads at 10ms, a benefit of its lighter runtime. On idle memory, OpenFang sits at 40MB versus 180-394MB for Python frameworks. Install size is 32MB compared to 100-500MB for others.

On the dimensions that reflect architectural depth, OpenFang leads comprehensively. 16 security layers versus a maximum of 6 for any competitor. 40 channel adapters versus zero for CrewAI, AutoGen, and LangGraph. A Tauri 2.0 native desktop app that no other framework offers. A Merkle audit chain that no other framework offers.

The one area where OpenFang makes a deliberate trade-off is that it is not the lightest option. ZeroClaw's 10ms cold start and 5MB memory footprint reflect a different set of priorities. For long-running autonomous agents operating on schedules, start time is largely irrelevant — the agent runs once and stays running. For latency-critical interactive applications, ZeroClaw may be the better choice. For production autonomous agents that need security, channel coverage, and a complete runtime, OpenFang is in a class of its own.

The Technical Architecture

OpenFang's 14-crate Rust workspace is organized around a kernel-style design. Each crate handles a specific subsystem — channels, memory, security, tools, protocols, the Hands runtime, and so on — with clean boundaries between them.

Memory persistence is handled by SQLite with vector embeddings. Agents maintain cross-channel canonical sessions, meaning a user can move from Telegram to Discord to Slack and the agent maintains continuity of context. When conversation history grows large, automatic LLM-based compaction summarizes older context while preserving what's relevant. JSONL session mirroring provides a raw backup of every session for audit and recovery purposes.

Protocol support covers three layers. The Model Context Protocol operates as both a client (connecting to external MCP servers) and a server (exposing OpenFang tools to other agents). Google's A2A (Agent-to-Agent) protocol allows OpenFang agents to receive tasks from and delegate tasks to agents running in entirely different systems. The OpenFang Protocol (OFP) handles P2P networking between OpenFang instances with HMAC-SHA256 mutual authentication — the foundation for the distributed deployment mode Jaber has hinted at publicly.

The workflow engine supports multi-agent pipelines with fan-out steps (dispatching work to multiple agents in parallel), conditional steps (branching based on outcomes), and loop steps (repeating until a condition is met). The REST API exposes 140+ endpoints covering agents, memory, workflows, channels, models, skills, A2A tasks, and Hands — giving developers programmatic control over every aspect of the runtime.

The 30 pre-built agent templates span four performance tiers and cover use cases from orchestrators to code reviewers to customer support agents, deployable across Anthropic, Gemini, Groq, and DeepSeek providers.

Who Should Be Paying Attention

OpenFang is a developer tool, and it's specifically aimed at developers who want to build and deploy autonomous agents in production — not prototype them in a Jupyter notebook.

The single binary distribution and one-line install lower the barrier to getting started significantly. But the 62 environment variables, HAND.toml manifest format, per-channel model overrides, and granular security configuration mean this is designed for engineers who want control, not just a quick demo.

The open-source MIT license is a meaningful choice. It means companies can deploy OpenFang internally without licensing concerns, and the community can build on top of it freely. The combination of MIT licensing, a planned FangHub marketplace, and the existing protocol infrastructure (MCP, A2A, OFP) suggests a deliberate ecosystem strategy — not just a tool, but a platform.

Practically speaking, if you are building any of the following, OpenFang deserves serious evaluation: autonomous content pipelines, lead generation systems, competitive intelligence monitors, AI-assisted research workflows, multi-channel AI assistants, or any agent that needs to run reliably on a schedule without human intervention.

The Bottom Line

The agent framework space is crowded, but most of it is solving the same problem: making it easier to build chatbots that use tools. OpenFang is solving a different problem — making it possible to deploy agents that operate independently, securely, and reliably on production systems.

137,000 lines of Rust. Zero clippy warnings. 16 security systems. 7 Hands that work while you're not watching. A native desktop dashboard. A Merkle audit trail. A single binary.

Version 0.1.0 — and already the most architecturally serious Agent OS available as open source.

If you have been waiting for an agent framework that takes production deployment as seriously as feature development, OpenFang is worth your time.

Install it: curl -fsSL https://openfang.sh/install | sh GitHub: github.com/RightNow-AI/openfang Discord: discord.gg/sSJqgNnq6X