RustyHand MCP server
Commit Sep 8, 2026An autonomous agent operating system built in Rust that manages multiple agents, LLM providers, and communication channels like Telegram and Discord.
Also known as ginkida/rustyhand
- Stars
- 20
- Tools
- 29
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Sep 8, 2026
- License
- MIT
What is RustyHand MCP?
RustyHand is an autonomous agent operating system built in Rust that manages multiple agents, LLM providers, and communication channels like Telegram and Discord. It exposes 29 tools, such as rustyhand_system_health, rustyhand_system_status, rustyhand_config_get.
Summary generated from the project's README
About RustyHand MCP server
Managing autonomous agents that operate on schedules and communicate via messaging platforms is what RustyHand enables. This Rust-based operating system allows developers to deploy agents that run 24/7 to monitor targets, build knowledge graphs, or manage social media without constant human prompting. It functions as a single binary or a Docker container, providing a central kernel to manage multiple agents, LLM providers, and communication channels.
Users interact with the system through a React dashboard or via Telegram, which serves as the primary interface. The system supports various LLM providers including Anthropic, DeepSeek, Ollama, and OpenRouter. For those without API keys, a deterministic mock driver is available to test the full pipeline. The platform includes 72 built-in tools such as shell execution, web search, browser automation, and image vision to ensure agents can perform complex, real-world tasks autonomously.
What you can do with it
- 1Automated daily reportingSet up an agent to perform specific tasks on a cron schedule and push the results to your chat.
- 2Human-in-the-loop tool executionConfigure the system to request explicit permission before an agent executes sensitive shell commands.
- 3Rapid prototyping without credentialsTest the agent workflow and dashboard interactivity immediately using the built-in mock driver.
Written from the project's README. Every use case is checked against a quote from it.
RustyHand MCP tools 29
Detected from the READMErustyhand_system_healthrustyhand_system_statusrustyhand_config_getrustyhand_config_setrustyhand_config_reloadrustyhand_agent_listrustyhand_agent_getrustyhand_agent_spawnrustyhand_agent_killrustyhand_agent_messagerustyhand_agent_sessionrustyhand_agent_set_model
| rustyhand_system_health | — | |
| rustyhand_system_status | — | |
| rustyhand_config_get | — | |
| rustyhand_config_set | — | |
| rustyhand_config_reload | — | |
| rustyhand_agent_list | — | |
| rustyhand_agent_get | — | |
| rustyhand_agent_spawn | — | |
| rustyhand_agent_kill | — | |
| rustyhand_agent_message | — | |
| rustyhand_agent_session | — | |
| rustyhand_agent_set_model | — |
Show all 29 toolsShow fewer tools
rustyhand_agent_session_resetrustyhand_provider_listrustyhand_model_listrustyhand_budget_statusrustyhand_budget_agentsrustyhand_workflow_listrustyhand_workflow_runrustyhand_workflow_runsrustyhand_cron_listrustyhand_cron_createrustyhand_cron_deleterustyhand_approval_listrustyhand_approval_approverustyhand_approval_rejectrustyhand_channel_listrustyhand_template_listrustyhand_tool_list
| rustyhand_agent_session_reset | — | |
| rustyhand_provider_list | — | |
| rustyhand_model_list | — | |
| rustyhand_budget_status | — | |
| rustyhand_budget_agents | — | |
| rustyhand_workflow_list | — | |
| rustyhand_workflow_run | — | |
| rustyhand_workflow_runs | — | |
| rustyhand_cron_list | — | |
| rustyhand_cron_create | — | |
| rustyhand_cron_delete | — | |
| rustyhand_approval_list | — | |
| rustyhand_approval_approve | — | |
| rustyhand_approval_reject | — | |
| rustyhand_channel_list | — | |
| rustyhand_template_list | — | |
| rustyhand_tool_list | — |
Configuration
ANTHROPIC_API_KEYDEEPSEEK_API_KEYDISCORD_BOT_TOKENKIMI_API_KEYMINIMAX_API_KEYOPENROUTER_API_KEYRUSTYHAND_API_KEYRUST_LOGSLACK_APP_TOKENSLACK_BOT_TOKENTELEGRAM_BOT_TOKENVOYAGE_API_KEYZHIPU_API_KEY
| Name | Description | |
|---|---|---|
| ANTHROPIC_API_KEY | — | |
| DEEPSEEK_API_KEY | — | |
| DISCORD_BOT_TOKEN | — | |
| KIMI_API_KEY | — | |
| MINIMAX_API_KEY | — | |
| OPENROUTER_API_KEY | — | |
| RUSTYHAND_API_KEY | — | |
| RUST_LOG | — | |
| SLACK_APP_TOKEN | — | |
| SLACK_BOT_TOKEN | — | |
| TELEGRAM_BOT_TOKEN | — | |
| VOYAGE_API_KEY | — | |
| ZHIPU_API_KEY | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableginkida/rustyhand is public and reachablegithub.com/ginkida/rustyhand ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-09-08github.com/ginkida/rustyhand ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model29 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubv0.7.87 — Audit iteration 3: 27 verifier-confirmed fixes (June 2026) A third adversarial-audit sweep over API auth, channels, the kernel scheduler/workflows, memory/knowledge, and request routing — each finding gated behind a 3-lens refute panel. Closes an unauthenticated-Owner auth bypass (spoofed
X-Forwarded-For), redirect-based SSRF in the A2A and cron-webhook clients, an RHP pre-shared-key serialization leak, MCP allowlist/file-read hardening, a ~24× cost-quota over-count, cron validation/timezone correctness, workflow run-leak + persistence races, knowledge-graph multi-hop traversal, and Unicode-aware session search. See the release notes for details.Clone →
cargo run --release -- start→ open the dashboard → talk to an agent. No API key required. When no provider key is found in the environment, RustyHand falls back to a deterministic mock driver and seeds four sample resources so every major dashboard page is interactive on first visit:
rustywelcome agent (chat-ready)demo-pipelineworkflow (2-step sample, click to run)- sample agent-spawn trigger
demo-daily-pingcron job (registered, disabled by default)A welcome modal on first visit lists all four with one-click navigation. The CLI startup banner and Docker entrypoint both announce demo mode as a feature instead of a missing-key warning. Set
ANTHROPIC_API_KEY(or a Kimi / DeepSeek / Zhipu / MiniMax / OpenRouter / Ollama key) and restart for real LLM responses, orRUSTYHAND_DISABLE_DEMO_MODE=1to force a hard fail.Highlights since v0.7.41:
- React dashboard — every subsystem is a page: agents, chat, workflows, automation (cron + triggers), channels, analytics, knowledge graph, skills, approvals, audit, and a full
config.tomleditor.- Autonomous-by-default agents — tuned to act without asking; grant any agent all 72 tools live via
PATCH /api/agents/{id}/config(no respawn).- 72 built-in tools — shell, web/news search, browser automation, RAG, knowledge-graph CRUD, file ops, image vision, and config management.
- Trust-by-default security with visible guardrails —
GET /api/securityreports the real runtime posture (exec mode, approval policy, per-channel gating); flip to allowlist/deny withRUSTYHAND_EXEC_MODE.- Everything persists — audit log (Merkle hash chain), workflows, and triggers all survive daemon restart and are replayed/validated on boot.
Origin
This project is based on OpenFang by RightNow-AI, modified and extended for custom use cases.
Table of Contents
- What is RustyHand?
- Installation
- Quick Start
- Telegram Setup
- Configuration
- CLI Reference
- Autonomous Templates
- 40 Pre-built Agent Templates
- Channel Adapters
- 7 LLM Providers
- Architecture
- API Endpoints
- Dashboard
- Security
- Deployment
- Docker Environment Variables
- Development
- Benchmarks
- MCP Integration (for AI Agents)
- How It Works — Data Flow
- License
What is RustyHand?
RustyHand is an open-source Agent Operating System — not a chatbot framework, not a Python wrapper around an LLM. It is a full operating system for autonomous agents, built from scratch in Rust.
Traditional agent frameworks wait for you to type something. RustyHand runs autonomous agents that work for you — on schedules, 24/7, building knowledge graphs, monitoring targets, generating leads, managing social media, and reporting results directly to your Telegram chat.
Telegram-First Autonomous Agent
Telegram is the primary interface for RustyHand agents. Your agent can:
| Capability | How it works |
|---|---|
| See photos | Auto-describes images via vision API |
| Hear voice | Auto-transcribes voice messages via Whisper |
| Receive files | Downloads documents, forwards to agent |
| Send files/photos/voice | Sends generated content back to chat |
| Ask permission | Inline keyboard buttons (Approve/Reject) pushed automatically |
| Show progress | Real-time tool-use updates: "⚙️ web_search..." → "✅ Done" |
| Report autonomously | Background tasks push results to your chat without prompting |
| 72 built-in tools | Shell, web/news search, browser (wait, JS exec, scroll, download), RAG, knowledge graph, file ops, image vision |
| Markdown formatting | Bold, italic, code blocks render natively in Telegram |
| Reply threading | Responses reply to the user's message for clean conversation flow |
| Sticker/GIF/Location | Agent understands stickers, animations, and shared locations |
The entire system compiles to a single ~32MB binary. One install, one command, your agents are live.
Installation
One-liner (Linux / macOS / WSL)
curl -fsSL https://raw.githubusercontent.com/ginkida/rustyhand/main/scripts/install.sh | sh
Environment variables:
RUSTY_HAND_INSTALL_DIR— custom install path (default:~/.rustyhand/bin)RUSTY_HAND_VERSION— pin a specific version tag
Windows (PowerShell)
irm https://raw.githubusercontent.com/ginkida/rustyhand/main/scripts/install.ps1 | iex
From source
git clone https://github.com/ginkida/rustyhand.git
cd rustyhand
cargo build --release -p rusty-hand-cli
# Binary: target/release/rustyhand (or rustyhand.exe on Windows)
Requires Rust 1.75+ (stable). The rust-toolchain.toml in the repo will auto-select the right toolchain.
Docker
docker compose up --build
# Dashboard at http://localhost:4200
Or run directly with env vars (no config.toml needed):
docker run -p 4200:4200 \
-e ANTHROPIC_API_KEY=your-key \
-e RUSTYHAND_API_KEY=my-secret-bearer-token \
-v rustyhand-data:/data \
ghcr.io/ginkida/rustyhand:latest
All configuration can be set via RUSTYHAND_* environment variables — see Docker Environment Variables.
Quick Start
Option Zero: Try it in 30 seconds, no API key
The fastest possible first run, no credentials, no configuration:
git clone https://github.com/ginkida/rustyhand
cd rustyhand
cargo run --release -- start
# In another tab: open http://localhost:4200
The dashboard banner will read "DEMO MODE — running on the deterministic
mock driver." Spawn an agent, send a message, watch the agent loop run,
session grow, audit log fill up. Every reply is [mock] <your message> —
unmistakably demo, but the full pipeline (sessions, persistence, workflows,
cron jobs) is real. Set ANTHROPIC_API_KEY (or any of 26 other supported
providers' env vars) and restart for real LLM responses.
Option A: Docker (fastest)
docker run -d --name rustyhand \
-p 4200:4200 \
-e ANTHROPIC_API_KEY=your-key \
-v rustyhand-data:/data \
ghcr.io/ginkida/rustyhand:latest
# Dashboard: http://localhost:4200
# API: http://localhost:4200/api/health
To secure the API with a bearer token:
docker run -d --name rustyhand \
-p 4200:4200 \
-e ANTHROPIC_API_KEY=your-key \
-e RUSTYHAND_API_KEY=my-secret-token \
-v rustyhand-data:/data \
ghcr.io/ginkida/rustyhand:latest
# Now all API calls require: -H "Authorization: Bearer my-secret-token"
See Docker Environment Variables for all options.
Option B: From binary
# 1. Initialize — creates ~/.rustyhand/ and walks you through provider setup
rustyhand init
# 2. Start the daemon (API + kernel)
rustyhand start
# Dashboard is live at http://localhost:4200
# 3. Chat with the default agent
rustyhand chat
# 4. Spawn a pre-built agent
rustyhand agent new coder
# 5. Send a one-shot message
rustyhand message researcher "What are the emerging trends in AI agent frameworks?"
# 6. Launch the interactive TUI dashboard
rustyhand tui
# 7. Run diagnostics
rustyhand doctor
Telegram Setup
Telegram is the primary channel for interacting with RustyHand agents. Setup takes 2 minutes:
1. Create a Telegram Bot
- Message @BotFather on Telegram
- Send
/newbot, follow prompts, get your bot token - Set the token:
export TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
2. Configure RustyHand
# ~/.rustyhand/config.toml
[channels.telegram]
bot_token_env = "TELEGRAM_BOT_TOKEN"
allowed_users = [] # Empty = allow anyone. Set [123456] for specific user IDs.
3. Start and chat
rustyhand start
# Open Telegram, message your bot
# /agents — list agents
# /agent assistant — select an agent
# Send text, photos, voice messages — the agent handles all of them
What your agent can do in Telegram
You: [send a voice message]
Agent: [auto-transcribes via Whisper, processes your request]
You: [send a photo]
Agent: [auto-describes the image, responds based on what it sees]
You: "Search for Rust 2024 edition changes"
Agent: ⚙️ web_search...
✅ web_search
Here are the key changes in Rust 2024...
Agent: ⚠️ Agent "coder" wants to execute:
`shell_exec: rm -rf /tmp/cache`
[✅ Approve] [❌ Reject] ⏱️ 60s
You: [click ✅ Approve]
Agent: Done! Cache cleared.
Autonomous mode
Agents with schedule_mode = "continuous" or "periodic" run in the background and push results to your Telegram chat automatically — no prompting needed.
# agent.toml
[schedule]
mode = "periodic"
cron = "0 9 * * *" # Every day at 9 AM
The agent wakes up, performs its task, and sends the result to the last Telegram chat it was used in.
Configuration
RustyHand can be configured in two ways:
- Config file (
~/.rustyhand/config.toml) — for binary installs - Environment variables (
RUSTYHAND_*) — for Docker, see Docker Environment Variables
API Authentication
When api_key is set, all endpoints (except /api/health) require a Bearer token:
# In config.toml:
api_key = "my-secret-token"
# Or via env var (Docker):
RUSTYHAND_API_KEY=my-secret-token
# Clients must include the header:
curl -H "Authorization: Bearer my-secret-token" http://localhost:4200/api/agents
Without api_key, the API is open (fine for local development).
Config file
Location: ~/.rustyhand/config.toml
# API server settings
api_key = "your-bearer-token" # Recommended for non-localhost access
api_listen = "127.0.0.1:4200" # HTTP bind address
[default_model]
provider = "anthropic" # anthropic, kimi, deepseek, zhipu, minimax, openrouter, ollama
model = "claude-sonnet-4-6" # Model identifier
api_key_env = "ANTHROPIC_API_KEY" # Env var holding the API key
# base_url = "https://api.anthropic.com" # Optional: override endpoint
[memory]
decay_rate = 0.05 # Memory confidence decay
# sqlite_path = "~/.rustyhand/data/rustyhand.db"
[network]
listen_addr = "127.0.0.1:4200" # RHP P2P listen address
# shared_secret = "" # Required for P2P authentication
# Session compaction (LLM-based context management)
[compaction]
threshold = 80 # Compact when messages exceed this count
keep_recent = 20 # Keep this many recent messages
max_summary_tokens = 1024
# Usage display in chat responses
# usage_footer = "Full" # Off, Tokens, Cost, Full
# Channel adapters (tokens via env vars)
[telegram]
bot_token_env = "TELEGRAM_BOT_TOKEN"
allowed_users = [] # Empty = allow all
[discord]
bot_token_env = "DISCORD_BOT_TOKEN"
# guild_ids = []
[slack]
bot_token_env = "SLACK_BOT_TOKEN"
app_token_env = "SLACK_APP_TOKEN"
# MCP server connections
[[mcp_servers]]
name = "filesystem"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
Environment variables
Copy .env.example to ~/.rustyhand/.env and fill in the keys you need:
# LLM providers — set ANY key and RustyHand auto-detects the provider.
# Priority order: Anthropic → Kimi → DeepSeek → Zhipu → MiniMax → OpenRouter.
ANTHROPIC_API_KEY=sk-ant-... # Claude Opus / Sonnet / Haiku (default)
KIMI_API_KEY=sk-kimi-... # Kimi Code — Anthropic-compat, 256K ctx
DEEPSEEK_API_KEY=sk-... # DeepSeek V4 Flash / V4 Pro (V3/R1 legacy, deprecated 2026-07-24)
ZHIPU_API_KEY=... # Zhipu GLM-4.6
MINIMAX_API_KEY=eyJ... # MiniMax M1 / M2.7 (1M context)
OPENROUTER_API_KEY=sk-or-... # Universal gateway (GPT/Gemini/Grok/etc.)
# Local LLM — no key needed, just run `ollama serve`
# (Base URL defaults to http://localhost:11434/v1 — override only if needed)
# Embedding-only upstreams (independent of LLM provider)
VOYAGE_API_KEY=pa-... # Voyage AI (voyage-3-lite, code, legal, ...)
# OPENAI_API_KEY can also be used for text-embedding-3-* — not for LLM completion.
# Channel tokens
TELEGRAM_BOT_TOKEN=123456:ABC-...
DISCORD_BOT_TOKEN=...
SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
# Log level
RUST_LOG=info
# RUST_LOG=rusty_hand=debug # Debug RustyHand only
Manage config from the CLI
rustyhand config show # Print current config
rustyhand config edit # Open in $EDITOR
rustyhand config get default_model.provider # Read a key
rustyhand config set default_model.provider kimi # Switch provider
rustyhand config set-key kimi # Interactively save API key
rustyhand config test-key kimi # Verify connectivity
CLI Reference
Core commands
| Command | Description |
|---|---|
rustyhand init |
Initialize ~/.rustyhand/ and default config |
rustyhand start |
Start the daemon (API server + kernel) |
rustyhand stop |
Stop the running daemon |
rustyhand status [--json] |
Show kernel status |
rustyhand health [--json] |
Quick daemon health check |
rustyhand doctor [--repair] |
Run diagnostic checks |
rustyhand tools [--json] |
List all 72 built-in tools, grouped by category (offline) |
rustyhand tui |
Launch interactive TUI dashboard |
rustyhand dashboard |
Open web dashboard in browser |
rustyhand chat [agent] |
Quick chat with an agent |
rustyhand message <agent> <text> |
Send a one-shot message |
rustyhand logs [--follow] [--lines N] |
Tail the log file |
rustyhand reset [--confirm] |
Reset local config and state |
Agents
| Command | Description |
|---|---|
rustyhand agent new [template] |
Spawn from a template (interactive picker if omitted) |
rustyhand agent templates [--json] |
List the bundled agent templates (offline) |
rustyhand agent spawn <manifest.toml> |
Spawn from a manifest file |
rustyhand agent list [--json] |
List running agents |
rustyhand agent chat <id> |
Interactive chat with an agent by ID |
rustyhand agent kill <id> |
Kill an agent |
Channels
| Command | Description |
|---|---|
rustyhand channel list |
List configured channels and status |
rustyhand channel setup [name] |
Interactive channel setup wizard |
rustyhand channel test <name> |
Send a test message |
rustyhand channel enable <name> |
Enable a channel |
rustyhand channel disable <name> |
Disable a channel |
Models
| Command | Description |
|---|---|
rustyhand models list [--provider X] |
Browse available models |
rustyhand models aliases |
Show model shorthand names |
rustyhand models providers |
List providers and their auth status |
rustyhand models set [model] |
Set the default model |
Skills
| Command | Description |
|---|---|
rustyhand skill install <source> |
Install from ClawHub, local path, or git URL |
rustyhand skill list |
List installed skills |
rustyhand skill search <query> |
Search ClawHub marketplace |
rustyhand skill remove <name> |
Remove a skill |
rustyhand skill create |
Scaffold a new skill |
Workflows & scheduling
| Command | Description |
|---|---|
rustyhand workflow list |
List workflows |
rustyhand workflow create <file.json> |
Create from JSON |
rustyhand workflow run <id> <input> |
Run a workflow |
rustyhand trigger list [--agent-id X] |
List event triggers |
rustyhand trigger create <agent-id> <pattern-json> |
Create a trigger |
rustyhand cron list |
List scheduled jobs |
Integrations (MCP)
| Command | Description |
|---|---|
rustyhand add <name> [--key TOKEN] |
Install an integration (e.g., github, notion) |
rustyhand remove <name> |
Remove an integration |
rustyhand integrations [query] |
List / search integrations |
Security & vault
| Command | Description |
|---|---|
rustyhand vault init |
Initialize the credential vault (AES-256-GCM) |
rustyhand vault set <key> |
Store a credential |
rustyhand vault list |
List stored keys (values hidden) |
rustyhand vault remove <key> |
Remove a credential |
rustyhand security audit |
View the audit trail |
rustyhand security rbac |
Manage access control |
Other
| Command | Description |
|---|---|
rustyhand mcp |
Start MCP server over stdio |
rustyhand sessions [agent] |
List conversation sessions |
rustyhand approvals list |
List pending approval requests |
rustyhand qr |
Generate device pairing QR code |
rustyhand onboard |
Interactive onboarding wizard |
rustyhand completion <shell> |
Generate shell completions (bash/zsh/fish/powershell) |
rustyhand new skill|integration |
Scaffold a new skill or integration |
All list/status commands support --json for scripting.
Autonomous Templates
RustyHand ships autonomous templates as agent presets in the dashboard. They are not a separate runtime entity: each template creates a normal agent, and you can optionally attach a cron schedule during creation.
Each autonomous template bundles:
- Agent preset — model, profile, prompt, and capabilities
- Schedule defaults — suggested cron expression and trigger message
- Operational playbook — multi-phase prompt for recurring work
- Guardrails — approval and tool constraints where needed
Bundled Autonomous Templates
| Template | What It Does |
|---|---|
| GitHub Monitor | Monitors repositories, runs tests, detects regressions, and files issues on a schedule. |
| Web Researcher | Runs recurring research sweeps, cross-references sources, and produces structured reports. |
| Content Clipper | Processes long-form video into short clips with captions and packaging. |
| Lead Generator | Discovers and enriches qualified leads on a recurring schedule. |
| Intel Collector | Monitors targets, detects changes, and updates a living knowledge base. |
| Predictor | Collects signals, updates forecasts, and tracks prediction accuracy. |
| Twitter Manager | Creates, schedules, and reviews social content with approval controls. |
| Web Browser | Executes recurring browser automation tasks with strict purchase approval gates. |
Use the dashboard to launch one: Agents → Templates or Create Agent → enable schedule.
40 Pre-built Agent Templates
Spawn any template with rustyhand agent new <name>:
| Template | Description |
|---|---|
analyst |
Data analysis and reporting |
api-monitor |
API endpoint monitoring |
architect |
System design and architecture |
assistant |
General-purpose assistant |
capability-builder |
Meta-agent — writes new skills at runtime via privileged skill_install tool |
ci-monitor |
CI/CD pipeline monitoring |
code-reviewer |
Code review and feedback |
coder |
Software development |
coordinator |
Meta-agent — delegates work across other agents via agent_send |
customer-support |
Customer support |
dag-monitor |
DAG/workflow monitoring |
data-scientist |
Data science and ML |
db-reporter |
Database reporting |
debugger |
Bug investigation |
devops-lead |
DevOps and infrastructure |
diagnostic |
Meta-agent — read-only observability (self-history, metrics, audit log) |
doc-writer |
Documentation |
email-assistant |
Email drafting and management |
health-tracker |
Health and fitness tracking |
hello-world |
Starter agent for new users |
home-automation |
Smart home control |
legal-assistant |
Legal document review |
log-analyzer |
Log analysis and alerting |
meeting-assistant |
Meeting notes and follow-ups |
ops |
Operations management |
orchestrator |
Multi-agent orchestration |
personal-finance |
Financial tracking |
planner |
Project planning |
recruiter |
Recruiting and screening |
researcher |
Research and analysis |
sales-assistant |
Sales support |
security-auditor |
Security analysis |
slack-notifier |
Slack notification automation |
social-media |
Social media management |
test-engineer |
Testing and QA |
translator |
Multi-language translation |
travel-planner |
Travel planning |
tutor |
Education and tutoring |
weekly-digest |
Weekly summary reports |
writer |
Content writing |
Agent manifest format (agent.toml)
name = "hello-world"
version = "0.1.0"
description = "A friendly greeting agent"
author = "rusty-hand"
module = "builtin:chat"
[model]
provider = "anthropic"
model = "claude-sonnet-4-6"
max_tokens = 4096
temperature = 0.6
system_prompt = """Your system prompt here..."""
[resources]
max_llm_tokens_per_hour = 100000
[capabilities]
tools = ["file_read", "file_list", "web_fetch", "web_search", "memory_store", "memory_recall"]
network = ["*"]
memory_read = ["*"]
memory_write = ["self.*"]
agent_spawn = false
RustyHand MCP questions
What tools does RustyHand MCP provide?
It exposes 29 tools, including rustyhand_system_health, rustyhand_system_status, rustyhand_config_get, rustyhand_config_set, rustyhand_config_reload.
Do I need an API key to try RustyHand?
No, if no provider key is found, it falls back to a deterministic mock driver with sample resources for interactive testing.