This fork adds the following changes on top of upstream OpenFang:
ollama_structured tool — Calls Ollama with JSON schema enforcement for guaranteed structured output. Agents use this for precise computed values (timestamps, numbers) instead of relying on LLM math.
Multi-user sender_id — Passes the Telegram chat_id through the bridge > kernel > agent loop > tool runner. cron_create automatically replaces last_channel with the sender's actual chat_id, preventing race conditions where multiple users' reminders deliver to the wrong chat.
Direct cron delivery — When a cron job with Channel delivery fires, the message is sent directly to Telegram without going through the LLM. Prevents rephrasing of reminder text.
Action normalization — system_event actions in cron_create are automatically converted to agent_turn so reminders deliver via Telegram channels.
# Build
git clone https://github.com/797th/openfang.git && cd openfang
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
cargo build --release -p openfang-cli
# Install
curl -fsSL https://openfang.sh/install | sh
cp target/release/openfang ~/.openfang/bin/openfang
# Config (from companion repo)
git clone -b nideesh https://github.com/797th/openfang-ollama-telegram.git
cp openfang-ollama-telegram/native/config.toml ~/.openfang/config.toml
cp -r openfang-ollama-telegram/native/agents ~/.openfang/agents
cp openfang-ollama-telegram/native/.env.example ~/.openfang/.env
# Edit ~/.openfang/.env with your TELEGRAM_BOT_TOKEN and NVIDIA_API_KEY
# Ollama (for structured output + embeddings)
ollama pull gpt-oss:20b
ollama pull nomic-embed-text
# Run
set -a && source ~/.openfang/.env && set +a
openfang start --config ~/.openfang/config.toml
Open-source Agent OS built in Rust. 137K LOC. 14 crates. 1,767+ tests. Zero clippy warnings.
One binary. Battle-tested. Agents that actually work for you.
Documentation • Quick Start • Twitter / X
v0.5.10 (April 2026)
OpenFang is feature complete but still pre-1.0. Expect rough edges and breaking changes between minor versions. We ship fast and fix fast. Pin to a specific commit for production use until v1.0. Report issues here.
OpenFang is an open-source Agent Operating System. Not a chatbot framework. Not a Python wrapper around an LLM. Not a "multi-agent orchestrator." A full operating system for autonomous agents, built from scratch in Rust.
Traditional agent frameworks wait for you to type something. OpenFang runs autonomous agents that work for you: on schedules, 24/7, building knowledge graphs, monitoring targets, generating leads, managing your social media, and reporting results to your dashboard.
The entire system compiles to a single ~32MB binary. One install, one command, your agents are live.
curl -fsSL https://openfang.sh/install | sh
openfang init
openfang start
# Dashboard live at http://localhost:4200Windows
irm https://openfang.sh/install.ps1 | iex
openfang init
openfang start"Traditional agents wait for you to type. Hands work for you."
Hands are OpenFang's core innovation. Pre-built autonomous capability packages that run independently, on schedules, without you having to prompt them. This is not a chatbot. This is an agent that wakes up at 6 AM, researches your competitors, builds a knowledge graph, scores the findings, and delivers a report to your Telegram before you've had coffee.
Each Hand bundles:
- HAND.toml: manifest declaring tools, settings, requirements, and dashboard metrics.
- System Prompt: multi-phase operational playbook. Not a one-liner. These are 500+ word expert procedures.
- SKILL.md: domain expertise reference injected into context at runtime.
- Guardrails: approval gates for sensitive actions (e.g. Browser Hand requires approval before any purchase).
All compiled into the binary. No downloading, no pip install, no Docker pull.
| Hand | What It Actually Does |
|---|---|
| Clip | Takes a YouTube URL, downloads it, identifies the best moments, cuts them into vertical shorts with captions and thumbnails, optionally adds AI voice-over, and publishes to Telegram and WhatsApp. 8-phase pipeline. FFmpeg + yt-dlp + 5 STT backends. |
| Lead | Runs daily. Discovers prospects matching your ICP, enriches them with web research, scores 0-100, deduplicates against your existing database, and delivers qualified leads in CSV/JSON/Markdown. Builds ICP profiles over time. |
| Collector | OSINT grade intelligence. You give it a target (company, person, topic). It monitors continuously: change detection, sentiment tracking, knowledge graph construction, and critical alerts when something important shifts. |
| Predictor | Superforecasting engine. Collects signals from multiple sources, builds calibrated reasoning chains, makes predictions with confidence intervals, and tracks its own accuracy using Brier scores. Has a contrarian mode that deliberately argues against consensus. |
| Researcher | Deep autonomous researcher. Cross-references multiple sources, evaluates credibility using CRAAP criteria (Currency, Relevance, Authority, Accuracy, Purpose), generates cited reports with APA formatting, supports multiple languages. |
| Autonomous Twitter/X account manager. Creates content in 7 rotating formats, schedules posts for optimal engagement, responds to mentions, tracks performance metrics. Has an approval queue, so nothing posts without your OK. | |
| Browser | Web automation agent. Navigates sites, fills forms, clicks buttons, handles multi-step workflows. Uses Playwright bridge with session persistence. Mandatory purchase approval gate: it will never spend your money without explicit confirmation. |
# 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 listBuild your own. Define a HAND.toml with tools, settings, and a system prompt. Publish to FangHub.
All data from official documentation and public repositories, February 2026.
ZeroClaw ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10 ms
OpenFang ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 180 ms ★
LangGraph █████████████████░░░░░░░░░░░░░░░░░░░░░░░░░ 2.5 sec
CrewAI ████████████████████░░░░░░░░░░░░░░░░░░░░░░ 3.0 sec
AutoGen ██████████████████████████░░░░░░░░░░░░░░░░░ 4.0 sec
OpenClaw █████████████████████████████████████████░░ 5.98 sec
ZeroClaw █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 5 MB
OpenFang ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 40 MB ★
LangGraph ██████████████████░░░░░░░░░░░░░░░░░░░░░░░░░ 180 MB
CrewAI ████████████████████░░░░░░░░░░░░░░░░░░░░░░░ 200 MB
AutoGen █████████████████████████░░░░░░░░░░░░░░░░░░ 250 MB
OpenClaw ████████████████████████████████████████░░░░ 394 MB
ZeroClaw █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 8.8 MB
OpenFang ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 32 MB ★
CrewAI ████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 100 MB
LangGraph ████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 150 MB
AutoGen ████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░ 200 MB
OpenClaw ████████████████████████████████████████░░░░ 500 MB
OpenFang ████████████████████████████████████████████ 16 ★
ZeroClaw ███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 6
OpenClaw ████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 3
AutoGen █████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2
LangGraph █████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2
CrewAI ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1
OpenFang ████████████████████████████████████████████ 40 ★
ZeroClaw ███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 15
OpenClaw █████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 13
CrewAI ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0
AutoGen ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0
LangGraph ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0
ZeroClaw ████████████████████████████████████████████ 28
OpenFang ██████████████████████████████████████████░░ 27 ★
LangGraph ██████████████████████░░░░░░░░░░░░░░░░░░░░░ 15
CrewAI ██████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10
OpenClaw ██████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10
AutoGen ███████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 8
| Feature | OpenFang | OpenClaw | ZeroClaw | CrewAI | AutoGen | LangGraph |
|---|---|---|---|---|---|---|
| Language | Rust | TypeScript | Rust | Python | Python | Python |
| Autonomous Hands | 7 built-in | None | None | None | None | None |
| Security Layers | 16 discrete | 3 basic | 6 layers | 1 basic | Docker | AES enc. |
| Agent Sandbox | WASM dual-metered | None | Allowlists | None | Docker | None |
| Channel Adapters | 40 | 13 | 15 | 0 | 0 | 0 |
| Built-in Tools | 53 + MCP + A2A | 50+ | 12 | Plugins | MCP | LC tools |
| Memory | SQLite + vector | File-based | SQLite FTS5 | 4-layer | External | Checkpoints |
| Desktop App | Tauri 2.0 | None | None | None | Studio | None |
| Audit Trail | Merkle hash-chain | Logs | Logs | Tracing | Logs | Checkpoints |
| Cold Start | <200ms | ~6s | ~10ms | ~3s | ~4s | ~2.5s |
| Install Size | ~32 MB | ~500 MB | ~8.8 MB | ~100 MB | ~200 MB | ~150 MB |
| License | MIT | MIT | MIT | MIT | Apache 2.0 | MIT |
OpenFang doesn't bolt security on after the fact. Every layer is independently testable and operates without a single point of failure.
| # | System | What It Does |
|---|---|---|
| 1 | WASM Dual-Metered Sandbox | Tool code runs in WebAssembly with fuel metering + epoch interruption. A watchdog thread kills runaway code. |
| 2 | Merkle Hash-Chain Audit Trail | Every action is cryptographically linked to the previous one. Tamper with one entry and the entire chain breaks. |
| 3 | Information Flow Taint Tracking | Labels propagate through execution. Secrets are tracked from source to sink. |
| 4 | Ed25519 Signed Agent Manifests | Every agent identity and capability set is cryptographically signed. |
| 5 | SSRF Protection | Blocks private IPs, cloud metadata endpoints, and DNS rebinding attacks. |
| 6 | Secret Zeroization | Zeroizing<String> auto-wipes API keys from memory the instant they're no longer needed. |
| 7 | OFP Mutual Authentication | HMAC-SHA256 nonce-based, constant-time verification for P2P networking. |
| 8 | Capability Gates | Role based access control. Agents declare required tools, the kernel enforces it. |
| 9 | Security Headers | CSP, X-Frame-Options, HSTS, X-Content-Type-Options on every response. |
| 10 | Health Endpoint Redaction | Public health check returns minimal info. Full diagnostics require authentication. |
| 11 | Subprocess Sandbox | env_clear() + selective variable passthrough. Process tree isolation with cross-platform kill. |
| 12 | Prompt Injection Scanner | Detects override attempts, data exfiltration patterns, and shell reference injection in skills. |
| 13 | Loop Guard | SHA256-based tool call loop detection with circuit breaker. Handles ping-pong patterns. |
| 14 | Session Repair | 7-phase message history validation and automatic recovery from corruption. |
| 15 | Path Traversal Prevention | Canonicalization with symlink escape prevention. ../ doesn't work here. |
| 16 | GCRA Rate Limiter | Cost-aware token bucket rate limiting with per-IP tracking and stale cleanup. |
14 Rust crates. 137,728 lines of code. Modular kernel design.
openfang-kernel Orchestration, workflows, metering, RBAC, scheduler, budget tracking
openfang-runtime Agent loop, 3 LLM drivers, 53 tools, WASM sandbox, MCP, A2A
openfang-api 140+ REST/WS/SSE endpoints, OpenAI-compatible API, dashboard
openfang-channels 40 messaging adapters with rate limiting, DM/group policies
openfang-memory SQLite persistence, vector embeddings, canonical sessions, compaction
openfang-types Core types, taint tracking, Ed25519 manifest signing, model catalog
openfang-skills 60 bundled skills, SKILL.md parser, FangHub marketplace
openfang-hands 7 autonomous Hands, HAND.toml parser, lifecycle management
openfang-extensions 25 MCP templates, AES-256-GCM credential vault, OAuth2 PKCE
openfang-wire OFP P2P protocol with HMAC-SHA256 mutual authentication
openfang-cli CLI with daemon management, TUI dashboard, MCP server mode
openfang-desktop Tauri 2.0 native app (system tray, notifications, global shortcuts)
openfang-migrate OpenClaw, LangChain, AutoGPT migration engine
xtask Build automation
Connect your agents to every platform your users are on.
Core: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Email (IMAP/SMTP) Enterprise: Microsoft Teams, Mattermost, Google Chat, Webex, Feishu/Lark, Zulip Social: LINE, Viber, Facebook Messenger, Mastodon, Bluesky, Reddit, LinkedIn, Twitch Community: IRC, XMPP, Guilded, Revolt, Keybase, Discourse, Gitter Privacy: Threema, Nostr, Mumble, Nextcloud Talk, Rocket.Chat, Ntfy, Gotify Workplace: Pumble, Flock, Twist, DingTalk, Zalo, Webhooks
Each adapter supports per-channel model overrides, DM/group policies, rate limiting, and output formatting.
Connect your personal WhatsApp account to OpenFang via QR code, just like WhatsApp Web. No Meta Business account required.
- Node.js >= 18 installed (download)
- OpenFang installed and initialized
1. Install the gateway dependencies:
cd packages/whatsapp-gateway
npm install2. Configure config.toml:
[channels.whatsapp]
mode = "web"
default_agent = "assistant"3. Set the gateway URL (choose one):
Add to your shell profile for persistence:
# macOS / Linux
echo 'export WHATSAPP_WEB_GATEWAY_URL="http://127.0.0.1:3009"' >> ~/.zshrc
source ~/.zshrcOr set it inline when starting the gateway:
export WHATSAPP_WEB_GATEWAY_URL="http://127.0.0.1:3009"4. Start the gateway:
node packages/whatsapp-gateway/index.jsThe gateway listens on port 3009 by default. Override with WHATSAPP_GATEWAY_PORT.
5. Start OpenFang:
openfang start
# Dashboard at http://localhost:42006. Scan the QR code:
Open the dashboard → Channels → WhatsApp. A QR code will appear. Scan it with your phone:
WhatsApp → Settings → Linked Devices → Link a Device
Once scanned, the status changes to connected and incoming messages are routed to your configured agent.
| Variable | Description | Default |
|---|---|---|
WHATSAPP_WEB_GATEWAY_URL |
Gateway URL for OpenFang to connect to | (empty = disabled) |
WHATSAPP_GATEWAY_PORT |
Port the gateway listens on | 3009 |
OPENFANG_URL |
OpenFang API URL the gateway reports to | http://127.0.0.1:4200 |
OPENFANG_DEFAULT_AGENT |
Agent that handles incoming messages | assistant |
| Method | Route | Description |
|---|---|---|
POST |
/login/start |
Generate QR code (returns base64 PNG) |
GET |
/login/status |
Connection status (disconnected, qr_ready, connected) |
POST |
/message/send |
Send a message ({ "to": "5511999999999", "text": "Hello" }) |
GET |
/health |
Health check |
For production workloads, use the WhatsApp Cloud API with a Meta Business account. See the Cloud API configuration docs.
3 native drivers (Anthropic, Gemini, OpenAI-compatible) route to 27 providers:
Anthropic, Gemini, OpenAI, Groq, DeepSeek, OpenRouter, Together, Mistral, Fireworks, Cohere, Perplexity, xAI, AI21, Cerebras, SambaNova, HuggingFace, Replicate, Ollama, vLLM, LM Studio, Qwen, MiniMax, Zhipu, Moonshot, Qianfan, Bedrock, and more.
Intelligent routing with task complexity scoring, automatic fallback, cost tracking, and per-model pricing.
Already running OpenClaw? One command:
# Migrate everything: agents, memory, skills, configs.
openfang migrate --from openclaw
# Migrate from a specific path
openfang migrate --from openclaw --path ~/.openclaw
# Dry run first to see what would change
openfang migrate --from openclaw --dry-runThe migration engine imports your agents, conversation history, skills, and configuration. OpenFang reads SKILL.md natively and is compatible with the ClawHub marketplace.
Drop-in replacement. Point your existing tools at OpenFang:
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
}'140+ REST/WS/SSE endpoints covering agents, memory, workflows, channels, models, skills, A2A, Hands, and more.
# 1. Install (macOS/Linux)
curl -fsSL https://openfang.sh/install | sh
# 2. Initialize. Walks you through provider setup.
openfang init
# 3. Start the daemon
openfang start
# 4. Dashboard is live at http://localhost:4200
# 5. Activate a Hand. It starts working for you.
openfang hand activate researcher
# 6. Chat with an agent
openfang chat researcher
> "What are the emerging trends in AI agent frameworks?"
# 7. Spawn a pre-built agent
openfang agent spawn coderWindows (PowerShell)
irm https://openfang.sh/install.ps1 | iex
openfang init
openfang start# Build the workspace
cargo build --workspace --lib
# Run all tests (1,767+)
cargo test --workspace
# Lint (must be 0 warnings)
cargo clippy --workspace --all-targets -- -D warnings
# Format
cargo fmt --all -- --checkOpenFang v0.5.10 is pre-1.0. The architecture is solid, the test suite is comprehensive, and the security model is deep. That said:
- Breaking changes may occur between minor versions until v1.0.
- Some Hands are more mature than others. Browser and Researcher are the most battle tested.
- Edge cases exist. If you find one, open an issue.
- Pin to a specific commit for production deployments until v1.0.
We ship fast and fix fast. The goal is a rock solid v1.0 by mid 2026.
To report a security vulnerability, email jaber@rightnowai.co. We take all reports seriously and will respond within 48 hours.
MIT. Use it however you want.
OpenFang is built and maintained by Jaber, Founder of RightNow.
Website •
Twitter / X •
Built with Rust. Secured with 16 layers. Agents that actually work for you.
Layer 1 — The OpenFang service
Repo is https://github.com/797th/openfang.git (local clone /root/CLAUDE/GITHUB/openfang, branch main). The pattern you already have is one directory per server under deploy/: 797th/, kamd1/, rancher/. So adding a server means adding deploy// with two files: config.template.toml and openfang.yaml.
Start by copying deploy/797th/ — it's the most complete variant (it's the only one carrying the ConfigMap inline and the securityContext). Then substitute the placeholders the manifest header documents:
- ${DOMAIN} (e.g. 797th vs pageapp), ${IMAGE_TAG}, ${DOCKER_CONFIG_JSON} (base64 dockerconfigjson for your registry)
- ${OPENFANG_API_KEY}, ${SCREENBUDDY_API_KEY}
- Deployment env: NVIDIA_API_KEY, OLLAMA_API_KEY, TELEGRAM_BOT_TOKEN, OPENFANG_WEBHOOK_TOKEN, CLUSTER_NAME, DOMAIN, ENVIRONMENT_TYPE, VERSION
The manifest is self-contained across 8 kinds: Namespace, Secret, ConfigMap, PVC, Deployment, Service, IngressRoute, Middleware.
Cluster prerequisites you must confirm before applying — these are exactly where 797th bit you:
- Traefik CRDs must exist, or IngressRoute/Middleware fail to apply and kubectl apply exits non-zero while everything else lands. On 797th they're absent, so the domain never routes and the service is only reachable on its LoadBalancer IP. Check first: kubectl get crd | grep traefik.
- A wildcard TLS secret for *. must already exist — the manifest assumes it, doesn't create it.
- A StorageClass for the PVC (797th uses 1Gi, kamd1 uses 10Gi).
- If you use embedding_provider = "ollama", the ollama service must actually exist. It doesn't on 797th, so memory embeddings silently fail there.
Layer 2 — Agents
33 agent definitions live in the repo at agents//agent.toml — analyst, coder, researcher, security-auditor, nideesh-agent, etc. Each is a flat TOML: name/module = "builtin:chat"/[model] block with provider, api_key_env, max_tokens, temperature, and a long system_prompt.
Only a subset gets baked into the image — deploy/agents/ currently holds just assistant and openfang-company (per the most recent commit, "reset baked agents to openfang-company + assistant"). deploy/entrypoint.sh seeds those onto the data volume on first boot with cp -rn, so it never clobbers agents already on the volume. Practical consequences for a new server:
- To ship an agent by default, add its directory under deploy/agents/.
- Set default_agent in config.template.toml under [channels.telegram] — this is the one line that differs between 797th (openfang-company) and kamd1 (nideesh-agent).
- Because seeding is cp -n, editing a baked agent won't propagate to an existing volume. Wipe the PVC path or edit in place.
Layer 3 — The Claude Code environment ("the nice behavior")
Worth knowing before you try to copy it: almost none of it is custom. There is no ~/.claude/agents/, no ~/.claude/skills/, no ~/.claude/commands/, and no user-level CLAUDE.md on this box. The agents (Explore, Plan, general-purpose) and skills (code-review, dataviz, simplify) are all stock Claude Code. No MCP servers are configured either.
What's genuinely portable is small:
- ~/.claude/settings.json — the wakatime marketplace entry + enabledPlugime: dark, agentPushNotifEnabled
- ~/.claude/settings.local.json — a kubectl permission allowlist that cut
- ~/.claude/projects/-root/memory/ — this is the real asset. Four files odge plus MEMORY.md as the index. Copy this directory to the new box; it's what makes the assistant behave "nicely" rather than rediscovering the sa
- WakaTime: install the plugin, then write ~/.wakatime.cfg with both api__url the CLI ships your activity to wakatime.com with no error.
- In-repo: CLAUDE.md and AGENTS.md (the latter defines the health stack —b, cargo clippy -- -D warnings, cargo test --workspace, shellcheck scripts/install.sh).
Layer 4 — Carry these lessons over
- Keep the readiness/liveness probes on /api/health:4200. A bad config.to logs a WARN, falls back to defaults, and binds 127.0.0.1:50051, so the Service's targetPort: 4200 reaches nothing. That produced a 12-hour greenvert it into a held rollout.
- Don't let lines in the manifest's inline config.toml get truncated — a AML but invalid TOML, which triggers exactly the above.
- OPENFANG_WEBHOOK_TOKEN must equal OPENFANG_API_KEY and the ScreenBuddy three together.
- If deploying through the Rancher UI, turn off "Always Build" and "Buildthem — multi-arch builds the amd64 half under QEMU on aarch64 nodes and dominates wall-clock. Config-only changes need no rebuild.
- Don't reorder the IngressRoute priorities; the webhook route deliberatedleware.
- If you'll run Claude Code as more than one unix user on the new box, se— otherwise you hit the /tmp/juju-wakatime-* lock collision I diagnosed earlier today.
Two things I did not verify, so treat as open: whether scripts/install.sh-metal path (there's also deploy/openfang.service for systemd, which suggests it does), and the current v0.0.x image tag series in Harbor.
result: Delivered a layered replication guide for standing OpenFang up on97th/ as the per-server template, verify Traefik CRDs/TLSsecret/StorageClass/ollama prerequisites, bake agents via deploy/agents/ de settings and the memory directory (everything else is stock ClaudeCode), and keep the /api/health:4200 probes that turn a fail-open config