FastClaw
A self-hosted multi-agent runtime for operating isolated, configurable chat agents from one control plane.
- Source repo
- fastclaw-ai/fastclaw
- Stars
- ★ 1.4k
- Last updated
- 2d ago
- License
- NOASSERTION
- Primary language
- Go
- FA score
- 63/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API · Claude API
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A SaaS team provisioning a separate bot for each customer can use a user API key and
X-Fastclaw-End-Userto lazily create users with isolated sessions, memory, and files. - Not a fit if
- Teams hosting multi-tenant SaaS for unrelated organizations: the Community License requires a commercial license
- Teams that want to remove or modify dashboard branding: the license forbids it
- Source review
- 63/100 · Some gaps
What does this agent do, and when should you use it?
FastClaw is a lightweight Go AI agent runtime positioned as an Agent Factory for creating, managing, and running agents. Each agent can have its own SOUL.md, memory, skills, tools, model overrides, sessions, and channel bindings, managed through a web dashboard, CLI, and HTTP APIs. The runtime handles LLM communication, tool execution, session isolation, and Docker or E2B sandboxing; SQLite is the default store, with Postgres documented for multi-pod deployments. It exposes Telegram, Discord, and Slack channels plus an OpenAI-compatible chat-completions endpoint, making it a fit for teams building a self-hosted agent backend or application integration layer.
On first launch, fastclaw opens a setup wizard to configure an LLM provider and create a default agent; the dashboard can edit system files such as SOUL.md, IDENTITY.md, and MEMORY.md, and configure models, skills, IM channels, and schedules. For incoming chats, the runtime stores sessions isolated by agent × user and by channel/chatID, and can invoke built-in exec, read_file, write_file, list_dir, web_fetch, web_search, and memory_search tools. With sandboxing enabled, Docker or E2B environments hydrate skills and workspaces, then sync sandbox-side files back to durable storage after each tool call. Applications can call streaming /v1/chat/completions, provision isolated end users through POST /v1/users or X-Fastclaw-End-User, while administrators manage resources through /api/agents, /api/config, /api/skills/install, and /api/apikeys.
- A SaaS team provisioning a separate bot for each customer can use a user API key and
X-Fastclaw-End-Userto lazily create users with isolated sessions, memory, and files. - An internal platform team operating several role-specific assistants can give every agent its own SOUL.md, model settings, skills, and private skill directory.
- A team delivering a focused support or business bot in Telegram, Discord, or Slack can bind that channel to an agent and keep individual chat threads separate.
- An application developer who needs a chat-agent backend can call the streaming OpenAI-compatible
/v1/chat/completionsendpoint instead of driving the web chat UI. - A team that needs agents to run code or manipulate files while constraining execution in hosted deployments can choose Docker or E2B sandboxing with
FASTCLAW_DEPLOY=hosted.
How do you install or deploy this agent?
Install:
curl -fsSL https://raw.githubusercontent.com/fastclaw-ai/fastclaw/main/install.sh | bashRun for the first time:
fastclawConfigure an LLM provider in the wizard; it creates a default agent. To create an OpenAI-backed agent from the CLI, make OPENAI_API_KEY available in the environment, then run:
fastclaw agents init alpha --provider openai --model openai/gpt-4o-mini --api-key-env OPENAI_API_KEYThe dashboard is at http://localhost:18953; use fastclaw daemon start for background execution.
How do you use this agent?
Use fastclaw agents ls to inspect agents, fastclaw agents config alpha set temperature 0.7 to change agent configuration, and fastclaw agents files put alpha SOUL.md ./SOUL.md to upload an identity file. In the dashboard, open an agent to test chat, install private skills, bind Telegram/Discord/Slack, inspect sessions, and manage cron jobs created by that agent. For application integration, send OpenAI-compatible streaming requests to /v1/chat/completions; a multi-tenant app uses a user API key and X-Fastclaw-End-User: <your-app-user-id>.
What are this agent's strengths and limitations?
- A single Go binary combines the dashboard, CLI, runtime, session management, and HTTP API, reducing the amount of infrastructure a team must assemble.
- Agent-level model overrides, skills, identity files, channels, and user-partitioned sessions and memory support multiple independently configured roles in one deployment.
- SQLite provides a simple default path, while Postgres, Redis, object storage, and Kubernetes are explicitly documented for scaled deployments.
- Docker and E2B sandboxing include skill/workspace synchronization; hosted mode can force exec and file calls inside the sandbox.
- The FastClaw Community License adds restrictions: hosting multi-tenant SaaS for unrelated organizations requires a commercial license, and dashboard branding may not be removed or modified.
- LLM providers, bot channels, and external web search/fetch require network access and relevant provider or bot credentials; the supplied material does not establish service costs or quotas.
- On self-hosted installations, host-shell execution is the default unless the model chooses
exec(sandbox:true); deployments exposed to untrusted IM users needFASTCLAW_SANDBOX_ENFORCE=1for hosted-style enforcement. - Multi-pod operation requires Postgres, Redis when shared channel leases and message streams are needed, and S3-compatible object storage for distributed skill/file hydration.
How does this agent compare with similar options?
The repository topics label FastClaw as an OpenClaw alternative; the supplied material does not provide a verifiable feature-by-feature comparison.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| FastClaw This agent | 63 · Some gaps | CLIFree + model costs | ★ 1.4k | 2d ago | Go | OpenAI API · Claude API |
| Shannon | 56 · Major gaps | Self-hosted serviceFree + model costs | ★ 2.3k | 2mo ago | Go | OpenAI API · Claude API |
| Omnara Managed Agent Platform | 68 · Some gaps | Hosted serviceFreemium | ★ 3.4k | 1d ago | Go | Codex · Claude Code · Claude.ai · OpenAI API · Claude API |
| Osaurus | 76 · Good | Desktop appFree + model costs | ★ 8.1k | 1d ago | Swift | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The docs describe API key tiers, sandbox isolation, server-side credential storage, and static encryption of sandbox tokens with rotation impacts, supporting the least-privilege and sensitive-data scores. The integration guide explicitly tells the application to authorize each user on every call, but the code-runner skill says to execute immediately, install dependencies automatically, and retry, without a confirmation mechanism. Tools, channels, and scheduling can cause external effects, while the supplied material does not fully explain default authorization, revocation, or a general recovery path, so those scores are reduced. The docs describe sandbox failure and rotation recovery paths and disclose some limitations; a dependency manifest is present, but no dependency security review is evidenced.
The README, CLI source, and deployment notes broadly describe one runtime, but the skill guide refers to fastclaw.json while the README says configuration is env-only; there is also a truncated document and mixed fastagent naming. These inconsistencies limit the self-consistency score. The Go module pins concrete dependency versions and describes SQLite, Postgres, and optional Redis deployment shapes. CLI error returns and HTTP error examples offer some failure guidance, but the evidence does not establish clear handling for all runtime failures.
The product covers fixed and dynamic agents, personal and multi-tenant integrations, multiple LLMs, messaging channels, and local and cloud deployments, with guidance on API key capabilities and use cases. Capability boundaries are explained, but the code-runner skill has a broad trigger and an unconditional execute-now instruction, limiting trigger precision. Environment variables, operating-system builds, and deployment options are covered, though the skill search paths include an older configuration model, so environment guidance is not fully consistent.
The README is organized around architecture, configuration, deployment, CLI, and API, with installation steps, configuration tables, examples, and stated limitations; the skill guide also provides a structured format. Its skill search directories conflict with the current configuration description, and fastclaw/fastagent naming is mixed, reducing naming stability. The license and its additional terms are disclosed, but it is not simply permissive Apache 2.0. Build versioning is described, while the evidence lacks a complete changelog and a clear ongoing maintenance responsibility statement.
The runtime combines agent management, tool execution, session memory, sandboxing, channels, and API integration, with concrete installation, CLI, and integration examples that indicate substantial intended value. Outputs are accessible through APIs, streaming interfaces, and the CLI, but the supplied evidence is insufficient to assess actual output quality. External services, databases, and sandboxes add deployment and operational costs; the docs describe options from local to multi-replica use but do not show quantified cost-benefit evidence.
The README, main program, Go dependency manifest, license, and sandbox design docs make product claims traceable. The sandbox rotation doc names specific tests and describes their semantics, providing partial cross-file corroboration, but this review did not execute tests. The docs often distinguish configuration facts, design decisions, and accepted failure windows; some test and security behavior is only asserted in documentation and cannot be independently confirmed from the supplied code excerpt, so the score is not full.
- The code-runner skill directs agents to execute code immediately, install missing dependencies automatically, and retry; review that skill and tool permissions before deployment, especially for untrusted chat users.
- The skill guide refers to fastclaw.json and legacy skill directories that differ from the README's env-only configuration description; verify the actual configuration paths for the target version before deployment.
- The license restricts multi-tenant hosting and UI branding changes; confirm the intended use complies with its additional terms.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/fastclaw)<a href="https://followagents.com/en/agents/fastclaw"><img src="https://followagents.com/badge/fastclaw.svg" alt="FARS review"></a>Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
Full Changelog: https://github.com/fastclaw-ai/fastclaw/compare/v1.5.0...v1.5.1View on GitHub ↗ -
Release notes excerpt
Full Changelog: https://github.com/fastclaw-ai/fastclaw/compare/v1.4.0...v1.5.0View on GitHub ↗ -
Release notes excerpt
Full Changelog: https://github.com/fastclaw-ai/fastclaw/compare/v1.3.1...v1.4.0View on GitHub ↗
FAQ
Which models can FastClaw use?
Can an external application isolate data for its own end users?
X-Fastclaw-End-User, or POST /v1/users, creates a stable internal identity for an external user; sessions, memory, and files are isolated per end user.How safe are shell and file operations?
FASTCLAW_DEPLOY=hosted, exec and file calls are locked in the sandbox. Self-hosted mode defaults to the host shell, unless FASTCLAW_SANDBOX_ENFORCE=1 enables hosted-style lockdown.Can it be operated without the dashboard?
fastclaw agents manages agents, configuration, and system files in the same store, while fastclaw apikey creates, rotates, and deletes API keys.Thanks — we use this to improve the page.