Skip to main content

What Are Hands?

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

Hands vs Agents

AspectTraditional AgentsHands
InteractionYou chat with themThey work for you
ActivationYou spawn manuallyYou activate from marketplace
OperationReactive (wait for messages)Autonomous (run on schedules)
ConfigurationWrite manifest by handSettings UI with validation
PurposeGeneral-purpose assistantDomain-complete capability package
ExpertiseDepends on your prompt500+ word operational playbook + SKILL.md
GuardrailsYou implementBuilt-in approval gates
Think of Hands as autonomous employees and traditional agents as chatbot assistants.

HAND.toml Format

Every Hand is defined by a HAND.toml manifest:
HAND.toml
id = "clip"
name = "Clip Hand"
description = "YouTube to vertical shorts pipeline with AI voice-over"
category = "content"
icon = "🎬"

# Tools this hand needs access to
tools = [
    "shell_exec",
    "file_read",
    "file_write",
    "file_list",
    "memory_store",
    "memory_recall",
    "web_fetch",
]

# Skill allowlist (empty = all skills available)
skills = ["ffmpeg-expert", "audio-processing"]

# MCP server allowlist (empty = all connected MCP servers)
mcp_servers = []

# Requirements that must be satisfied before activation
[[requires]]
key = "ffmpeg"
label = "FFmpeg must be installed"
requirement_type = "binary"
check_value = "ffmpeg"
description = "FFmpeg is the core video processing engine for Clip."

[requires.install]
macos = "brew install ffmpeg"
windows = "winget install Gyan.FFmpeg"
linux_apt = "sudo apt install ffmpeg"
linux_dnf = "sudo dnf install ffmpeg-free"
linux_pacman = "sudo pacman -S ffmpeg"
manual_url = "https://ffmpeg.org/download.html"
estimated_time = "2-5 min"

[[requires]]
key = "yt-dlp"
label = "yt-dlp must be installed"
requirement_type = "binary"
check_value = "yt-dlp"

[requires.install]
pip = "pip install yt-dlp"
macos = "brew install yt-dlp"
windows = "winget install yt-dlp.yt-dlp"
linux_apt = "sudo apt install yt-dlp"

[[requires]]
key = "GROQ_API_KEY"
label = "Groq API Key"
requirement_type = "api_key"
check_value = "GROQ_API_KEY"
description = "Groq powers the AI transcription engine."

[requires.install]
signup_url = "https://console.groq.com/keys"
docs_url = "https://console.groq.com/docs/quickstart"
env_example = "GROQ_API_KEY=gsk_..."
estimated_time = "5 min"
steps = [
    "Go to console.groq.com and sign up",
    "Navigate to API Keys section",
    "Generate a new API key",
    "Set GROQ_API_KEY environment variable",
]

# Configurable settings (shown in activation modal)
[[settings]]
key = "stt_provider"
label = "Speech-to-Text Provider"
description = "Which transcription engine to use"
setting_type = "select"
default = "auto"

[[settings.options]]
value = "auto"
label = "Auto-detect (tries all available)"

[[settings.options]]
value = "groq"
label = "Groq Whisper (fast, accurate)"
provider_env = "GROQ_API_KEY"

[[settings.options]]
value = "openai"
label = "OpenAI Whisper (most accurate)"
provider_env = "OPENAI_API_KEY"

[[settings.options]]
value = "deepgram"
label = "Deepgram (real-time capable)"
provider_env = "DEEPGRAM_API_KEY"

[[settings.options]]
value = "local"
label = "Local Whisper (no API key needed)"
binary = "whisper"

[[settings]]
key = "output_format"
label = "Output Format"
description = "Where to save the generated clips"
setting_type = "select"
default = "local"

[[settings.options]]
value = "local"
label = "Save locally"

[[settings.options]]
value = "telegram"
label = "Send to Telegram"

[[settings.options]]
value = "whatsapp"
label = "Send to WhatsApp"

[[settings]]
key = "enable_tts"
label = "Enable AI Voice-Over"
description = "Add AI-generated voice-over to clips"
setting_type = "toggle"
default = "false"

[[settings]]
key = "custom_outro"
label = "Custom Outro Text"
description = "Text to display at end of clips (leave empty for none)"
setting_type = "text"
default = ""

# Agent configuration
[agent]
name = "clip-hand"
description = "Autonomous YouTube clip generator"
module = "builtin:chat"
provider = "anthropic"
model = "claude-sonnet-4-20250514"
max_tokens = 8192
temperature = 0.7
system_prompt = '''
You are Clip Hand, an autonomous video processing agent...

[500+ word operational playbook with 8-phase pipeline]

Phase 1: Download
Phase 2: Transcribe
Phase 3: Identify highlights
Phase 4: Extract clips
Phase 5: Add captions
Phase 6: Generate thumbnails
Phase 7: (Optional) Add voice-over
Phase 8: Deliver
'''

# Dashboard metrics
[dashboard]
metrics = [
    { label = "Videos Processed", memory_key = "videos_processed", format = "number" },
    { label = "Clips Generated", memory_key = "clips_generated", format = "number" },
    { label = "Total Duration", memory_key = "total_duration_seconds", format = "duration" },
    { label = "Processing Time", memory_key = "avg_processing_seconds", format = "duration" },
]
FieldTypeRequiredDescription
idstringUnique hand identifier
namestringHuman-readable name
descriptionstringWhat this Hand does
categoryHandCategorycontent / security / productivity / development / communication / data
iconstringIcon emoji
toolsVec<String>Tools the agent needs
skillsVec<String>Skill allowlist (empty = all)
mcp_serversVec<String>MCP server allowlist
requiresVec<HandRequirement>Requirements to satisfy
settingsVec<HandSetting>Configurable settings
agentHandAgentConfigAgent manifest template
dashboardHandDashboardMetrics schema

The 7 Bundled Hands

OpenFang ships with 7 production-ready Hands:
What it does: 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/WhatsApp.8-phase pipeline:
  1. Download video with yt-dlp
  2. Transcribe audio (5 STT backends: Groq/OpenAI/Deepgram/AssemblyAI/Local)
  3. Identify highlights using LLM analysis of transcript
  4. Extract clips with FFmpeg (timestamps + vertical crop)
  5. Add captions (burned into video)
  6. Generate thumbnails (first frame extraction)
  7. (Optional) Add AI voice-over with ElevenLabs/OpenAI TTS
  8. Deliver to configured destination
Tech stack: FFmpeg, yt-dlp, Whisper, Claude/GPT-4 for analysisUse cases: Social media content creation, podcast highlights, tutorial clipsActivation: openfang hand activate clip
What it does: Runs daily. Discovers prospects matching your ICP (Ideal Customer Profile), enriches them with web research, scores 0-100, deduplicates against your existing database, and delivers qualified leads in CSV/JSON/Markdown.Pipeline:
  1. Load ICP profile from memory (or prompt you to define it)
  2. Search for prospects (LinkedIn, company directories, industry databases)
  3. Enrich each prospect (website, tech stack, funding, team size, etc.)
  4. Score against ICP criteria (0-100 scale)
  5. Deduplicate against existing leads (memory store)
  6. Rank by score
  7. Export top N leads
  8. Store enrichment data for future runs
Builds ICP over time: Learns from your feedback (“this is a good lead” → adjusts scoring).Use cases: Sales prospecting, partnership discovery, investor sourcingActivation: openfang hand activate lead
What it does: 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.Pipeline:
  1. Initial deep scan (web scraping, social media, public records)
  2. Build knowledge graph (entities + relations)
  3. Continuous monitoring (checks every N hours)
  4. Change detection (diff against previous state)
  5. Sentiment analysis (positive/negative/neutral trend)
  6. Critical alert triggers (keywords, thresholds)
  7. Report generation (daily/weekly summaries)
OSINT-grade: Uses advanced scraping techniques, proxy rotation, rate limit avoidance.Use cases: Competitive intelligence, reputation monitoring, threat detectionActivation: openfang hand activate collector
What it does: Collects signals from multiple sources, builds calibrated reasoning chains, makes predictions with confidence intervals, and tracks its own accuracy using Brier scores.Method:
  1. Frame prediction question clearly
  2. Gather base rates (historical data)
  3. Collect current signals (news, trends, indicators)
  4. Build reasoning chains (pro/con arguments)
  5. Assign confidence intervals (e.g., 60-75% likely)
  6. (Optional) Run contrarian mode (deliberately argue against consensus)
  7. Track outcome when prediction resolves
  8. Update Brier score (calibration metric)
Contrarian mode: Deliberately argues against consensus to surface blindspots.Use cases: Strategic planning, risk assessment, market analysisActivation: openfang hand activate predictor
What it does: 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.CRAAP credibility checks:
  • Currency: How recent is the information?
  • Relevance: How relevant to your question?
  • Authority: Who is the author? What are their credentials?
  • Accuracy: Can it be verified? Are sources cited?
  • Purpose: Why does this information exist? Bias?
Output formats: Markdown, PDF, HTML with full citationsUse cases: Academic research, fact-checking, due diligence, literature reviewsActivation: openfang hand activate researcher
What it does: Autonomous Twitter/X account manager. Creates content in 7 rotating formats, schedules posts for optimal engagement, responds to mentions, tracks performance metrics.7 content formats:
  1. Thread (deep dive)
  2. Quote tweet (commentary)
  3. Poll (engagement)
  4. Image + caption (visual)
  5. Video clip (from YouTube via Clip Hand)
  6. Link + summary (curation)
  7. Short take (opinion)
Approval queue: Nothing posts without your explicit OK. You review, edit, and approve.Scheduling: Auto-schedules for optimal engagement times based on your audience’s activity.Use cases: Personal brand building, company account management, thought leadershipActivation: openfang hand activate twitter
What it does: 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.Capabilities:
  • Navigate to URLs
  • Fill forms (text inputs, dropdowns, checkboxes)
  • Click buttons and links
  • Handle multi-step workflows (login → search → filter → extract)
  • Screenshot capture
  • Session persistence (cookies, localStorage)
Use cases: E-commerce automation, data extraction, form filling, account managementActivation: openfang hand activate browser

Lifecycle Management

Activate a Hand

# List available Hands
openfang hand list

# Check requirements for a Hand
openfang hand check clip

# Activate with default settings
openfang hand activate clip

# Activate with custom settings (JSON)
openfang hand activate clip --config '{"stt_provider": "groq", "enable_tts": true}'
When you activate:
  1. Requirement checks run:
    • Binary existence (e.g., ffmpeg on PATH)
    • Environment variables (e.g., GROQ_API_KEY set)
    • API key validity (optional ping to provider)
  2. Settings resolution:
    • Your config merged with defaults
    • Generates prompt block (appended to system prompt)
    • Collects required env vars for subprocess
  3. Agent spawn:
    • Kernel spawns agent with HandDefinition → AgentManifest conversion
    • Capabilities granted based on tools list
    • Skills and MCP servers filtered by allowlists
    • Workspace created at ~/.openfang/workspaces/{hand_id}-{instance_id}/
  4. Instance registered:
    • HandInstance saved to registry
    • Status set to Active
    • Dashboard metrics wired to memory keys
  5. Background loop starts (if schedule mode is continuous/periodic/proactive)
Code reference: crates/openfang-hands/src/registry.rs:activate_hand()

Pause a Hand

openfang hand pause clip
Status changes to Paused. Background loop stops. State persisted.

Resume a Hand

openfang hand resume clip
Status changes back to Active. Background loop restarts.

Deactivate a Hand

openfang hand deactivate clip
Agent is killed. Instance removed from registry. Workspace directory not deleted (contains data/logs).

Check Hand Status

openfang hand status clip
Outputs:
  • Instance ID
  • Status (Active/Paused/Error/Inactive)
  • Agent ID
  • Agent name
  • Activated at timestamp
  • Dashboard metrics (if any)

Settings System

Hands can declare configurable settings:

Setting Types

Dropdown menu with predefined options.
[[settings]]
key = "stt_provider"
label = "Speech-to-Text Provider"
setting_type = "select"
default = "auto"

[[settings.options]]
value = "groq"
label = "Groq Whisper"
provider_env = "GROQ_API_KEY"  # Shows "Ready" badge if env var exists

[[settings.options]]
value = "local"
label = "Local Whisper"
binary = "whisper"  # Shows "Ready" badge if binary on PATH
Resolves to:
  • Prompt block: - Speech-to-Text Provider: Groq Whisper (groq)
  • Env vars: ["GROQ_API_KEY"] (passed to subprocess)
Boolean on/off switch.
[[settings]]
key = "enable_tts"
label = "Enable AI Voice-Over"
setting_type = "toggle"
default = "false"
Resolves to: - Enable AI Voice-Over: Enabled (if true)
Free-form text input.
[[settings]]
key = "custom_outro"
label = "Custom Outro Text"
setting_type = "text"
default = ""
env_var = "CUSTOM_OUTRO"  # Exposes as env var if value provided
Resolves to: - Custom Outro Text: Thanks for watching!

Resolution Example

Given this config:
{
  "stt_provider": "groq",
  "enable_tts": true,
  "custom_outro": "Subscribe for more!"
}
Resolved settings:
## User Configuration

- Speech-to-Text Provider: Groq Whisper (groq)
- Enable AI Voice-Over: Enabled
- Custom Outro Text: Subscribe for more!
Env vars: ["GROQ_API_KEY", "CUSTOM_OUTRO"] Code reference: crates/openfang-hands/src/lib.rs:resolve_settings()

Dashboard Metrics

Hands can declare metrics displayed on the dashboard:
[dashboard]
metrics = [
    { label = "Videos Processed", memory_key = "videos_processed", format = "number" },
    { label = "Clips Generated", memory_key = "clips_generated", format = "number" },
    { label = "Total Duration", memory_key = "total_duration_seconds", format = "duration" },
    { label = "Avg Processing Time", memory_key = "avg_processing_seconds", format = "duration" },
]
The Hand updates these via memory_store tool:
<tool_use>
  <tool_name>memory_store</tool_name>
  <parameters>
    <key>videos_processed</key>
    <value>42</value>
  </parameters>
</tool_use>
Dashboard reads from memory and formats:
  • "number"42
  • "duration"2h 15m 30s
  • "bytes"1.2 GB

Building Your Own Hand

  1. Create HAND.toml:
    mkdir my-hand
    cd my-hand
    touch HAND.toml
    
  2. Define metadata and requirements:
    id = "my-hand"
    name = "My Hand"
    description = "Does something awesome"
    category = "productivity"
    tools = ["web_fetch", "memory_store"]
    
  3. Write system prompt (500+ words operational playbook):
    [agent]
    name = "my-hand"
    description = "..."
    system_prompt = '''
    You are My Hand, an autonomous agent that...
    
    OPERATIONAL PLAYBOOK
    
    Phase 1: ...
    Phase 2: ...
    Phase 3: ...
    '''
    
  4. Add dashboard metrics:
    [dashboard]
    metrics = [
        { label = "Tasks Completed", memory_key = "tasks_completed", format = "number" },
    ]
    
  5. Test locally:
    openfang hand install ./my-hand
    openfang hand activate my-hand
    
  6. Publish to FangHub:
    openfang hand publish ./my-hand
    

Next Steps

Activate Your First Hand

Step-by-step guide to activating Clip Hand

Build a Custom Hand

Create your own autonomous capability package

Memory System

Learn how Hands store and recall data

Security Model

Understand approval gates and guardrails

Build docs developers (and LLMs) love