OpenFang: seven Hands that run on a clock, not a prompt

Seven Hands compiled into one Rust binary

OpenFang is built for people who want agents to act on a clock instead of waiting for a prompt. Its unit of work is a Hand, and seven ship in the box. Clip takes a YouTube URL, cuts it into vertical shorts and publishes them to Telegram and WhatsApp. Lead discovers prospects matching an ICP, enriches them with web research and scores each one 0 to 100. Collector monitors a named target for change and sentiment. Researcher cross-references sources and grades them with CRAAP criteria. Predictor, Twitter and Browser complete the set, all seven in one table in the README.

A Hand is four files rather than a prompt string: a HAND.toml manifest declaring tools, settings, requirements and dashboard metrics, a system prompt written as a multi-phase playbook of 500 words or more, a SKILL.md reference injected into context at runtime, and guardrails describing approval gates. All of it is compiled into the ~32MB binary, so activation pulls nothing at runtime.

Read the workspace as a map of the system. crates/openfang-hands holds the Hands, and the workspace dependencies include prost and tokio-tungstenite, the latter commented as the WebSocket client for the Discord and Slack gateways. The README counts 137K lines of Rust across 14 crates and 1,767 or more tests. Writing your own means defining a HAND.toml and publishing it to FangHub.

curl into sh, then a dashboard on port 4200

Three commands put the dashboard on screen. The first one pipes a remote script into a shell, so read the contents at https://openfang.sh/install before running it. Then openfang init writes configuration and openfang start brings the daemon up at http://localhost:4200.

curl -fsSL https://openfang.sh/install | sh
openfang init
openfang start
# Dashboard live at http://localhost:4200

Windows uses a PowerShell equivalent that runs irm against install.ps1, then the same init and start pair.

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

Two ports are in play: 4200 serves the dashboard, while .env.example sets OPENFANG_LISTEN with a default of 127.0.0.1:3000 for the API server. Credentials are the only real input. That file lists keys for Anthropic, OpenAI, Groq, DeepSeek, OpenRouter, Together, Mistral, Fireworks and Novita, plus a Gemini key that can arrive as GEMINI_API_KEY or GOOGLE_API_KEY, and it points at three local model servers over HTTP: Ollama on 11434, vLLM on 8000 and LM Studio on 1234. Channel tokens cover Telegram, Discord, Slack, WhatsApp, Signal, Matrix and IMAP/SMTP email.

activate, status and pause: the Hand lifecycle on offer

Once the daemon is up, Hands are driven by subcommands, and five are demonstrated in the README. Activation starts the work immediately rather than queueing it, status reports progress, and pause stops a Hand while keeping its state. Notice the granularity: pause takes a Hand name, not a job id, so a Hand you did not write a schedule for has no lever smaller than the Hand itself.

# Activate the Researcher Hand. It starts working immediately.
openfang hand activate researcher

# Check its progress anytime
openfang hand status researcher

# Activate lead generation on a daily schedule
openfang hand activate lead

# Pause without losing state
openfang hand pause lead

# See all available Hands
openfang hand list

The README says results are reported to your dashboard. Daily behaviour is a property of the individual Hand: the Lead Hand is described as running daily, and the Predictor Hand as tracking its own accuracy over time.

Only the Browser and Twitter Hands stop to ask

Guardrails are one of the four parts each Hand bundles, and the README names them for two of the seven. Browser carries a mandatory purchase approval gate, so it will not spend money without explicit confirmation. Twitter has an approval queue, so nothing reaches the account without your OK. No approval step is described for the other five.

Clip downloads a video, cuts it and publishes it to Telegram and WhatsApp. Lead writes scored prospect records out as CSV, JSON or Markdown, and Collector raises critical alerts when a watched target shifts. Researcher produces cited APA reports, and Predictor has a contrarian mode that deliberately argues against consensus. Each of those runs unattended on a schedule, so what you have to get right before activating a Hand is its configuration, not a per-run confirmation. Among the commands the README shows, nothing stops every Hand at once.

The compose file builds from source because the GHCR image is not public

A Dockerfile and a compose file exist, and the comment at the top of the compose file explains why you cannot skip the build: ghcr.io/rightnow-ai/openfang is not yet public, the image line is commented out, and the file points at issue 12. Compilation happens on your machine, from a rust:1-slim-bookworm builder stage.

docker compose up --build

The service publishes one port and keeps its state in a named volume.

    ports:
      - "4200:4200"
    volumes:
      - openfang-data:/data

Seven variables are forwarded into the container: ANTHROPIC_API_KEY, OPENAI_API_KEY, GROQ_API_KEY, TELEGRAM_BOT_TOKEN, DISCORD_BOT_TOKEN, SLACK_BOT_TOKEN and SLACK_APP_TOKEN. Everything else in .env.example, including the three local model base URLs and the WhatsApp, Signal, Matrix and email credentials, stays on the host unless you add it to the environment list yourself. Reaching Ollama, whisper.cpp or a local Postgres on the host needs one more line uncommented, which the compose file says is required on Linux and colima.

    # extra_hosts:
    #   - "host.docker.internal:host-gateway"

The runtime stage also installs python3, python3-pip, python3-venv, nodejs and npm next to the binary, so the image carries a Python toolchain and Node that the 32MB install figure does not count. Builds default to ARG LTO=true with ARG CODEGEN_UNITS=1, and the Dockerfile documents --build-arg LTO=false --build-arg CODEGEN_UNITS=16 for dev environments. Entrypoint is openfang, the command is start, and OPENFANG_HOME is set to /data.

The comparison chart is the project's own, dated February 2026

The README carries four bar charts and labels their source as official documentation and public repositories, February 2026. Cold start is listed at 180 ms for OpenFang against 2.5 sec for LangGraph, 3.0 sec for CrewAI, 4.0 sec for AutoGen and 5.98 sec for OpenClaw. Idle memory is 40 MB against 180, 200, 250 and 394 MB. Install size is 32 MB against 150, 100, 200 and 500 MB. A fourth chart counts security systems at 16 for OpenFang and 6 for ZeroClaw.

The README attributes those numbers to official documentation and public repositories, so the ratios are compiled claims rather than measurements you can reproduce. The same table also shows ZeroClaw ahead of OpenFang on every resource measure in it, at 10 ms cold start, 5 MB idle and 8.8 MB installed. If you are sizing a small VM, that row matters more than the star printed next to OpenFang's bars. The alternative to weigh here is a graph-based Python library such as LangGraph, where you assemble the workflow yourself and nothing runs unless your code calls it: OpenFang inverts that, bundling the workflow, the schedule and the runtime into a compiled binary.

Version 0.6.9, a push on 2026-07-02, and a warning to pin your commit

v0.5.10, April 2026, carries the project's own warning: feature complete but still pre-1.0, expect rough edges and breaking changes between minor versions, ship fast and fix fast, and pin to a specific commit for production use until v1.0. The workspace package has moved to 0.6.9.

[workspace.package]
version = "0.6.9"
edition = "2021"
license = "Apache-2.0 OR MIT"
rust-version = "1.75"

The last push to main was on 2026-07-02. All three recent tags landed on 2026-05-12: v0.6.7 added Reconnect, Uninstall, Stop, Shell Env and TTS URLs, v0.6.8 carries no note of its own, and v0.6.9 is labelled security patches with nothing in the tag about what changed. CHANGELOG.md and MIGRATION.md sit at the repository root, and reading them before an upgrade is the practical answer to that pin instruction. Rust 1.75 is the floor, the edition is 2021, and storage is rusqlite 0.31 with the bundled feature, so SQLite is compiled in and no database server is needed. Both LICENSE-APACHE and LICENSE-MIT are in the root and the workspace declares Apache-2.0 OR MIT, so you choose which set of terms your build inherits.

Editorial conclusion

OpenFang fits a team that wants scheduled autonomy and can live inside a pre-1.0 Rust workspace: pin a commit as the README instructs, read CHANGELOG.md and MIGRATION.md before moving past 0.6.9, and configure the five Hands that run with no approval gate in front of them. Skip it on a small VM, where the project's own table puts ZeroClaw at 5 MB idle against 40 MB, and skip it if you need a stable API across minor versions. The first thing to check is your environment list, because docker-compose.yml forwards seven variables and .env.example names far more than that.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes