OpenFang: The Open-Source Agent Operating System That Works While You Sleep

TL;DR — OpenFang is a Rust-built, open-source Agent Operating System that ships as a single 32MB binary and runs fully autonomous AI agents — called Hands — on schedules, without you ever having to type a prompt.

What Is OpenFang?

OpenFang is not a chatbot wrapper, not a Python multi-agent orchestrator, and not another prompt-engineering framework. It is a full Agent Operating System — a foundational runtime for autonomous AI agents that work independently, on schedules, and report back to you.

Built from scratch in Rust by Jaber at RightNow, OpenFang compiles 137,728 lines of code across 14 crates into a single ~32MB binary. It cold-starts in under 200 milliseconds, idles at 40MB of RAM, passes 1,767+ tests, and ships with zero Clippy warnings. Version 0.1.0 dropped in February 2026 under the MIT License.

The philosophical distinction matters. Traditional agent frameworks are reactive — they wait for you to type something, then do it. OpenFang is proactive. You activate an agent, define its objective, and it wakes up on a schedule, performs research, builds knowledge graphs, monitors targets, generates leads, or manages your social accounts — and delivers results to your dashboard before you ask.

The Core Concept: Hands

The defining innovation in OpenFang is the concept of Hands — pre-built, autonomous capability packages that run independently without user prompting. Each Hand bundles a HAND.toml manifest declaring its tools and requirements, a multi-phase system prompt (often 500+ words of expert operational procedure), a SKILL.md domain expertise file injected into context at runtime, and built-in guardrails for sensitive actions such as purchase approval gates.

OpenFang ships with seven Hands out of the box:

None of these require a Docker pull or a pip install — all seven are compiled into the binary.

Installation

OpenFang installs as a single command on macOS and Linux:

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

On Windows via PowerShell:

irm https://openfang.sh/install.ps1 | iex

After installation, initialize the system. This interactive step walks you through selecting your LLM provider and configuring your first API key:

openfang init

Start the daemon:

openfang start

The dashboard is now live at http://localhost:4200. That is the entire installation. No runtime dependencies, no virtual environments, no container orchestration.

For development builds from source, clone the repository and use Cargo:

git clone https://github.com/RightNow-AI/openfang
cd openfang
cargo build --workspace --lib

Using OpenFang: A Practical Walkthrough

Activating Your First Hand

To put an autonomous agent to work immediately:

# Activate the Researcher Hand — it starts working right away
openfang hand activate researcher

# Check progress at any time
openfang hand status researcher

# Activate daily lead generation
openfang hand activate lead

# Pause without losing state
openfang hand pause lead

# See all available Hands
openfang hand list

Once activated, a Hand runs on its internal schedule. The Researcher Hand, for example, performs cross-source deep research, evaluates credibility using CRAAP criteria (Currency, Relevance, Authority, Accuracy, Purpose), and generates cited reports. You do not need to remain at the terminal.

Chatting with an Agent Directly

For interactive use, OpenFang provides a direct chat interface:

openfang chat researcher
> "Summarize the current state of Rust-based AI frameworks"

Spawning Pre-Built Agents

Beyond Hands, OpenFang ships with 30 pre-built agents covering domains such as coding, analysis, writing, and more:

openfang agent spawn coder

Using the OpenAI-Compatible API

OpenFang exposes a drop-in OpenAI-compatible API endpoint, making it usable with any tool that speaks the OpenAI chat completions format:

curl -X POST localhost:4200/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "researcher",
    "messages": [{"role": "user", "content": "Analyze Q4 market trends"}],
    "stream": true
  }'

This enables integration with existing editors, automation pipelines, and third-party tools without code changes.

LLM Providers and Channel Adapters

OpenFang connects to 27 LLM providers covering 123+ models through three native drivers (Anthropic, Gemini, and OpenAI-compatible). Supported providers include Anthropic, OpenAI, Groq, DeepSeek, Mistral, Ollama, LM Studio, vLLM, Perplexity, xAI, AWS Bedrock, and others. The routing layer applies task complexity scoring, automatic fallback on failure, per-model cost tracking, and configurable budget limits.

On the output side, 40 channel adapters let agents communicate across Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Microsoft Teams, Mastodon, Bluesky, Reddit, LinkedIn, Twitch, and dozens of additional platforms. Each adapter supports per-channel model overrides, rate limiting, and DM versus group policies.

Security Architecture

OpenFang ships with 16 discrete, independently testable security systems. The headline mechanism is a WASM dual-metered sandbox: all tool code runs inside WebAssembly with fuel metering and epoch interruption, and a watchdog thread forcibly terminates runaway processes. Alongside this, a Merkle hash-chain audit trail cryptographically links every agent action to the previous one — a single tampered entry breaks the entire chain. Other layers include Ed25519 signed agent manifests, information flow taint tracking for secrets, SSRF protection against cloud metadata endpoint attacks, automatic secret zeroization from memory, prompt injection scanning, SHA256-based loop detection with circuit breakers, and a GCRA rate limiter with per-IP tracking.

This depth of security engineering is rare in the open-source agent space. By comparison, CrewAI ships with one basic security layer and AutoGen relies on Docker for process isolation.

Migrating from OpenClaw

If you are running OpenClaw today, migration is a single command:

# Dry run first to preview changes
openfang migrate --from openclaw --dry-run

# Full migration of agents, memory, skills, and configs
openfang migrate --from openclaw

OpenFang reads SKILL.md natively and is compatible with the ClawHub marketplace, so existing skills carry over without modification.

Architecture and Performance

The 14-crate Rust workspace covers every layer of the system: openfang-kernel handles orchestration, scheduling, and budget tracking; openfang-runtime manages the agent loop, 53 built-in tools, and the WASM sandbox; openfang-channels covers the 40 messaging adapters; openfang-memory handles SQLite persistence and vector embeddings; openfang-desktop delivers a Tauri 2.0 native desktop application with system tray and global shortcuts; and openfang-migrate provides the import engine for OpenClaw, LangChain, and AutoGPT configurations.

Cold start benchmarked at 180ms compares favorably against LangGraph (2.5s), CrewAI (3.0s), AutoGen (4.0s), and OpenClaw (5.98s). Idle memory at 40MB sits well below LangGraph (180MB), CrewAI (200MB), AutoGen (250MB), and OpenClaw (394MB). The install footprint of 32MB is a fraction of the 100–500MB required by Python-based alternatives.

Stability and Production Readiness

OpenFang v0.1.0 is the first public release. The architecture and security model are comprehensive, and the test suite covers 1,767+ cases. That said, breaking changes may occur between minor versions until v1.0, some Hands are more battle-tested than others (Browser and Researcher being the most mature), and the project recommends pinning to a specific commit for production deployments. The stated goal is a stable v1.0 by mid-2026.

Where to Go Next

• GitHub: github.com/RightNow-AI/openfang
• Official Documentation: openfang.sh/docs
• Quick Start: openfang.sh/docs/getting-started
• Discord Community: discord.gg/sSJqgNnq6X
• License: MIT — use it however you want