Repository: RightNow-AI/openfang

Stars: 16739

CLAUDE.md

OpenFang — Agent Instructions

Project Overview

OpenFang is an open-source Agent Operating System written in Rust (14 crates).
- Config: ~/.openfang/config.toml
- Default API: http://127.0.0.1:4200
- CLI binary: target/release/openfang.exe (or target/debug/openfang.exe)

Build & Verify Workflow

After every feature implementation, run ALL THREE checks:

bash

cargo build --workspace --lib          # Must compile (use --lib if exe is locked)
cargo test --workspace                 # All tests must pass (currently 1744+)
cargo clippy --workspace --all-targets -- -D warnings  # Zero warnings

MANDATORY: Live Integration Testing

After implementing any new endpoint, feature, or wiring change, you MUST run live integration tests. Unit tests alone are not enough — they can pass while the feature is actually dead code. Live tests catch:
- Missing route registrations in server.rs
- Config fields not being deserialized from TOML
- Type mismatches between kernel and API layers
- Endpoints that compile but return wrong/empty data

How to Run Live Integration Tests

#### Step 1: Stop any running daemon

bash

tasklist | grep -i openfang
taskkill //PID <pid> //F
Wait 2-3 seconds for port to release

sleep 3

#### Step 2: Build fresh release binary

bash

cargo build --release -p openfang-cli

#### Step 3: Start daemon with required API keys

bash

GROQ_API_KEY=<key> target/release/openfang.exe start &
sleep 6  # Wait for full boot
curl -s http://127.0.0.1:4200/api/health  # Verify it's up

The daemon command is start (not daemon).

#### Step 4: Test every new endpoint

bash

GET endpoints — verify they return real data, not empty/null

curl -s http://127.0.0.1:4200/api/<new-endpoint>
POST/PUT endpoints — send real payloads

curl -s -X POST http://127.0.0.1:4200/api/<endpoint> \
  -H "Content-Type: application/json" \
  -d '{"field": "value"}'
Verify write endpoints persist — read back after writing

curl -s -X PUT http://127.0.0.1:4200/api/<endpoint> -d '...'
curl -s http://127.0.0.1:4200/api/<endpoint>  # Should reflect the update

#### Step 5: Test real LLM integration

bash

Get an agent ID

curl -s http://127.0.0.1:4200/api/agents | python3 -c "import sys,json; print(json.load(sys.stdin)[0]['id'])"
Send a real message (triggers actual LLM call to Groq/OpenAI)

curl -s -X POST "http://127.0.0.1:4200/api/agents/<id>/message" \
  -H "Content-Type: application/json" \
  -d '{"message": "Say hello in 5 words."}'

#### Step 6: Verify side effects
After an LLM call, verify that any metering/cost/usage tracking updated:

bash

curl -s http://127.0.0.1:4200/api/budget       # Cost should have increased
curl -s http://127.0.0.1:4200/api/budget/agents  # Per-agent spend should show

#### Step 7: Verify dashboard HTML

bash

Check that new UI components exist in the served HTML

curl -s http://127.0.0.1:4200/ | grep -c "newComponentName"
Should return > 0

#### Step 8: Cleanup

bash

tasklist | grep -i openfang
taskkill //PID <pid> //F

Key API Endpoints for Testing

| Endpoint | Method | Purpose |
|----------|--------|---------|
| /api/health | GET | Basic health check |
| /api/agents | GET | List all agents |
| /api/agents/{id}/message | POST | Send message (triggers LLM) |
| /api/budget | GET/PUT | Global budget status/update |
| /api/budget/agents | GET | Per-agent cost ranking |
| /api/budget/agents/{id} | GET | Single agent budget detail |
| /api/network/status | GET | OFP network status |
| /api/peers | GET | Connected OFP peers |
| /api/a2a/agents | GET | External A2A agents |
| /api/a2a/discover | POST | Discover A2A agent at URL |
| /api/a2a/send | POST | Send task to external A2A agent |
| /api/a2a/tasks/{id}/status | GET | Check external A2A task status |

Architecture Notes

- Don't touch openfang-cli — user is actively building the interactive CLI
- KernelHandle trait avoids circular deps between runtime and kernel
- AppState in server.rs bridges kernel to API routes
- New routes must be registered in server.rs router AND implemented in routes.rs
- Dashboard is Alpine.js SPA in static/index_body.html — new tabs need both HTML and JS data/methods
- Config fields need: struct field + #[serde(default)] + Default impl entry + Serialize/Deserialize derives

Common Gotchas

- openfang.exe may be locked if daemon is running — use --lib flag or kill daemon first
- PeerRegistry is Option<PeerRegistry> on kernel but Option<Arc<PeerRegistry>> on AppState — wrap with .as_ref().map(|r| Arc::new(r.clone()))
- Config fields added to KernelConfig struct MUST also be added to the Default impl or build fails
- AgentLoopResult field is .response not .response_text
- CLI command to start daemon is start not daemon
- On Windows: use taskkill //PID <pid> //F (double slashes in MSYS2/Git Bash)

README.md

<h1 align="center">OpenFang</h1>
<h3 align="center">The Agent Operating System</h3>

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.

<a href="https://openfang.sh/docs">Documentation</a> •
<a href="https://openfang.sh/docs/getting-started">Quick Start</a> •
<a href="https://x.com/openfangg">Twitter / X</a>

---

v0.3.30 — Security Hardening Release (March 2026)

> OpenFang is feature-complete but still pre-1.0. You may encounter rough edges or 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.

---

What is OpenFang?

OpenFang is an open-source Agent Operating System — not a chatbot framework, not a Python wrapper around an LLM, not a "multi-agent orchestrator." It is 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.

bash

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

<details>
<summary>Windows</summary>

powershell

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

</details>

---

Hands: Agents That Actually Do Things

"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.

The 7 Bundled Hands

| 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. |
| Twitter | 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 — 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. |

bash

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

Build your own. Define a HAND.toml with tools, settings, and a system prompt. Publish to FangHub.

---

OpenFang vs The Landscape

Benchmarks: Measured, Not Marketed

All data from official documentation and public repositories — February 2026.

#### Cold Start Time (lower is better)

text

ZeroClaw   ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   10 ms
OpenFang   ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  180 ms    ★
LangGraph  █████████████████░░░░░░░░░░░░░░░░░░░░░░░░░  2.5 sec
CrewAI     ████████████████████░░░░░░░░░░░░░░░░░░░░░░  3.0 sec
AutoGen    ██████████████████████████░░░░░░░░░░░░░░░░░  4.0 sec
OpenClaw   █████████████████████████████████████████░░  5.98 sec

#### Idle Memory Usage (lower is better)

text

ZeroClaw   █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    5 MB
OpenFang   ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   40 MB    ★
LangGraph  ██████████████████░░░░░░░░░░░░░░░░░░░░░░░░░  180 MB
CrewAI     ████████████████████░░░░░░░░░░░░░░░░░░░░░░░  200 MB
AutoGen    █████████████████████████░░░░░░░░░░░░░░░░░░  250 MB
OpenClaw   ████████████████████████████████████████░░░░  394 MB

#### Install Size (lower is better)

text

ZeroClaw   █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  8.8 MB
OpenFang   ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   32 MB    ★
CrewAI     ████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  100 MB
LangGraph  ████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  150 MB
AutoGen    ████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░  200 MB
OpenClaw   ████████████████████████████████████████░░░░  500 MB

#### Security Systems (higher is better)

text

OpenFang   ████████████████████████████████████████████   16      ★
ZeroClaw   ███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░    6
OpenClaw   ████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    3
AutoGen    █████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    2
LangGraph  █████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    2
CrewAI     ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    1

#### Channel Adapters (higher is better)

text

OpenFang   ████████████████████████████████████████████   40      ★
ZeroClaw   ███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░   15
OpenClaw   █████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   13
CrewAI     ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    0
AutoGen    ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    0
LangGraph  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    0

#### LLM Providers (higher is better)

text

ZeroClaw   ████████████████████████████████████████████   28
OpenFang   ██████████████████████████████████████████░░   27      ★
LangGraph  ██████████████████████░░░░░░░░░░░░░░░░░░░░░   15
CrewAI     ██████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   10
OpenClaw   ██████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   10
AutoGen    ███████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░    8

Feature-by-Feature Comparison

| 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 |

---

16 Security Systems — Defense in Depth

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. |

---

Architecture

14 Rust crates. 137,728 lines of code. Modular kernel design.

text

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

---

40 Channel Adapters

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.

---

WhatsApp Web Gateway (QR Code)

Connect your personal WhatsApp account to OpenFang via QR code — just like WhatsApp Web. No Meta Business account required.

Prerequisites

- Node.js >= 18 installed (download)
- OpenFang installed and initialized

Setup

1. Install the gateway dependencies:

bash

cd packages/whatsapp-gateway
npm install

2. Configure config.toml:

toml

[channels.whatsapp]
mode = "web"
default_agent = "assistant"

3. Set the gateway URL (choose one):

Add to your shell profile for persistence:

bash

macOS / Linux

echo 'export WHATSAPP_WEB_GATEWAY_URL="http://127.0.0.1:3009"' >> ~/.zshrc
source ~/.zshrc

Or set it inline when starting the gateway:

bash

export WHATSAPP_WEB_GATEWAY_URL="http://127.0.0.1:3009"

4. Start the gateway:

bash

node packages/whatsapp-gateway/index.js

The gateway listens on port 3009 by default. Override with WHATSAPP_GATEWAY_PORT.

5. Start OpenFang:

bash

openfang start
Dashboard at http://localhost:4200

6. 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.

Gateway Environment Variables

| 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 |

Gateway API Endpoints

| 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 |

Alternative: WhatsApp Cloud API

For production workloads, use the WhatsApp Cloud API with a Meta Business account. See the Cloud API configuration docs.

---

27 LLM Providers — 123+ Models

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.

---

Migrate from OpenClaw

Already running OpenClaw? One command:

bash

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-run

The migration engine imports your agents, conversation history, skills, and configuration. OpenFang reads SKILL.md natively and is compatible with the ClawHub marketplace.

---

OpenAI-Compatible API

Drop-in replacement. Point your existing tools at OpenFang:

bash

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.

---

Quick Start

bash

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 coder

<details>
<summary>Windows (PowerShell)</summary>

powershell

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

</details>

---

Development

bash

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 -- --check

---

Stability Notice

OpenFang v0.3.30 is pre-1.0. The architecture is solid, the test suite is comprehensive, and the security model is comprehensive. 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.

---

Security

To report a security vulnerability, email [email protected]. We take all reports seriously and will respond within 48 hours.

---

License

MIT — use it however you want.

---

Links

- Website & Documentation
- Quick Start Guide
- GitHub
- Discord
- Twitter / X

---

Built by RightNow

OpenFang is built and maintained by <a href="https://x.com/Akashi203">Jaber</a>, Founder of <a href="https://www.rightnowai.co/">RightNow</a>.

<a href="https://www.rightnowai.co/">Website</a> •
<a href="https://x.com/Akashi203">Twitter / X</a> •
<a href="https://www.buymeacoffee.com/openfang" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>

---

Built with Rust. Secured with 16 layers. Agents that actually work for you.

Repository: RightNow-AI/openfang

Stars: 16739

CLAUDE.md Copy Chapter

OpenFang — Agent Instructions

Project Overview Copy Chapter

Build & Verify Workflow Copy Chapter

MANDATORY: Live Integration Testing Copy Chapter

How to Run Live Integration Tests Copy Section

Wait 2-3 seconds for port to release

GET endpoints — verify they return real data, not empty/null

POST/PUT endpoints — send real payloads

Verify write endpoints persist — read back after writing

Get an agent ID

Send a real message (triggers actual LLM call to Groq/OpenAI)

Check that new UI components exist in the served HTML

Should return > 0

Key API Endpoints for Testing Copy Section

Architecture Notes Copy Chapter

Common Gotchas Copy Chapter

README.md Copy Chapter

What is OpenFang? Copy Chapter

Dashboard live at http://localhost:4200

Hands: Agents That Actually Do Things Copy Chapter

The 7 Bundled Hands Copy Section

Activate the Researcher Hand — it starts working immediately

Check its progress anytime

Activate lead generation on a daily schedule

Pause without losing state

See all available Hands

OpenFang vs The Landscape Copy Chapter

Benchmarks: Measured, Not Marketed Copy Section

Feature-by-Feature Comparison Copy Section

16 Security Systems — Defense in Depth Copy Chapter

Architecture Copy Chapter

40 Channel Adapters Copy Chapter

WhatsApp Web Gateway (QR Code) Copy Chapter

Prerequisites Copy Section

Setup Copy Section

macOS / Linux

Dashboard at http://localhost:4200

Gateway Environment Variables Copy Section

Gateway API Endpoints Copy Section

Alternative: WhatsApp Cloud API Copy Section

27 LLM Providers — 123+ Models Copy Chapter

Migrate from OpenClaw Copy Chapter

Migrate everything — agents, memory, skills, configs

Migrate from a specific path

Dry run first to see what would change

OpenAI-Compatible API Copy Chapter

Quick Start Copy Chapter

1. Install (macOS/Linux)

2. Initialize — walks you through provider setup

3. Start the daemon

4. Dashboard is live at http://localhost:4200

5. Activate a Hand — it starts working for you

6. Chat with an agent

7. Spawn a pre-built agent

Development Copy Chapter

Build the workspace

Run all tests (1,767+)

Lint (must be 0 warnings)

Format

Stability Notice Copy Chapter

Security Copy Chapter

License Copy Chapter

Links Copy Chapter

Built by RightNow Copy Chapter

Explore Related Technologies & Topics

CLAUDE.md

Project Overview

Build & Verify Workflow

MANDATORY: Live Integration Testing

How to Run Live Integration Tests

Key API Endpoints for Testing

Architecture Notes

Common Gotchas

README.md

What is OpenFang?

Hands: Agents That Actually Do Things

The 7 Bundled Hands

OpenFang vs The Landscape

Benchmarks: Measured, Not Marketed

Feature-by-Feature Comparison

16 Security Systems — Defense in Depth

Architecture

40 Channel Adapters

WhatsApp Web Gateway (QR Code)

Prerequisites

Setup

Gateway Environment Variables

Gateway API Endpoints

Alternative: WhatsApp Cloud API

27 LLM Providers — 123+ Models

Migrate from OpenClaw

OpenAI-Compatible API

Quick Start

Development

Stability Notice

Security

License

Links

Built by RightNow