AI agents are not just new software. They are software that can be talked into doing dangerous things. As agents move from chatbots to active systems that browse the web, execute code, and operate inside real workflows, we have handed language models the keys to our infrastructure before figuring out how to keep them on the rails.
This breaks traditional security assumptions entirely. In conventional systems, behavior is defined in code. In agents, behavior emerges at runtime from instructions, retrieved content, memory, and long decision loops. An attacker no longer needs to exploit a bug. They can manipulate the agent's reasoning, redirect its trajectory, or turn small permissions into larger ones over time. Prompt injection, tool misuse, and silent privilege escalation are not edge cases. They are structural properties of the execution model. Most teams only discover this when reading logs after the fact. That is forensics, not security.
XSafeClaw is built for that reality. It is an open-source defense platform that treats agent security as a live control problem, not a postmortem exercise. In the agent era, capability without defense is not progress. It is unmanaged exposure.
π Get Started Β Β·Β
π Documentation Β Β·Β
π Project Website Β Β·Β
βΆοΈ YouTube Demo
Release notes and project milestones.
| Date | Update | |
|---|---|---|
| π οΈ | 2026-04-26 | v1.0.5 released β Nanobot onboarding now follows the official install flow across platforms, setup no longer fails before API-key configuration, and Agent Valley's standalone page is wired up with the required React Query provider. |
| π₯ | 2026-04-25 | v1.0.4 released β XSafeClaw now publicly supports OpenClaw, nanobot, and Hermes side by side, while fixing several known bugs. |
| π₯ | 2026-04-23 | Hermes and runtime autostart β XSafeClaw now discovers OpenClaw, Hermes, and nanobot side by side, and best-effort starts installed gateways when the server boots. |
| π₯ | 2026-04-18 | nanobot local runtime support β XSafeClaw can now discover a local nanobot instance, start guarded chat sessions through nanobot gateway, and show mixed-runtime sessions together in Agent Valley. |
| π₯ | 2026-04-13 | v 1.0.0 released β First public release of XSafeClaw with Claw Monitor, Safe Chat, Asset Shield, Guard, Agent Office, and Onboard Setup. |
XSafeClaw is an open-source safety platform for AI agents, built to make agent behavior visible, controllable, and trustworthy. It turns complex agent execution into an intuitive visual βSafe Agent Valley,β providing real-time monitoring, risk interception, human-in-the-loop governance, and automated red-team testing β all accessible through a single xsafeclaw start command. The current runtime registry discovers local OpenClaw, Hermes Agent, and nanobot installations side by side, then lets you choose the runtime per session in Agent Town.
| Module | Description |
|---|---|
| Claw Monitor | Real-time session timeline with event tracking, token usage, tool call inspection, skills & memory scanning across OpenClaw, Hermes, and nanobot sessions |
| Safe Chat | Secure chat with OpenClaw, Hermes, or nanobot through each runtime's gateway/API |
| Asset Shield | File system scanning with risk classification (L0βL3), software audit, hardware inventory |
| Agent Guard | Trajectory-level & tool-call-level safety evaluation with human-in-the-loop approval |
| Pixel Office | PixiJS-powered 2D visualization of all agents' status and activities |
| Onboard Setup | Interactive setup for OpenClaw, Hermes, and nanobot, including model configuration and runtime guard integration |
pip install xsafeclaw
xsafeclaw startBrowser opens automatically at http://127.0.0.1:6874. If no supported runtime is installed, the web UI guides you through OpenClaw, Hermes, or nanobot setup.
Common options:
xsafeclaw start --port 8080 # custom port
xsafeclaw start --host 0.0.0.0 # accessible from LAN
xsafeclaw start --no-browser --reload # headless dev modeXSafeClaw's guard system protects users through a two-layer defense:
-
Trajectory-level evaluation β The full conversation history is sent to a guard model (AgentDoG) that evaluates the entire interaction sequence for emerging risks across multiple turns.
-
Tool-call interception β Every tool call passes through a
before_tool_callhook. If the guard model deems it unsafe, the call is held in a pending queue for human review.
Agent wants to run a tool
β
βΌ
Guard Model evaluates
β
ββββββ΄βββββ
β β
Safe Unsafe
β β
βΌ βΌ
Execute Hold for human review
ββββββ΄βββββ
β β
Approve Reject
β β
βΌ βΌ
Execute Block + notify agent
When rejected (or timed out after 5 min), the agent is instructed to stop all subsequent actions, inform the user about the risk, and wait for explicit confirmation.
Browser (:6874)
β
βββββββββββββ΄ββββββββββββ
β FastAPI Server β
βββββββββββββββββββββββββ€
β Runtime Registry ββββ OpenClaw / Hermes / nanobot discovery
β Runtime Autostart ββββ best-effort gateway startup
β Guard Service ββββ AgentDoG model
β File Watcher ββββ runtime JSONL sessions
β Asset Scanner ββββ file/software/hardware scanning
βββββββββββββ¬ββββββββββββ
β
SQLite DB β ~/.xsafeclaw/
β
βββββββββββββββββββββΌββββββββββββββββββββ
β β β
OpenClaw Agent Hermes Agent nanobot Agent
safeclaw plugin Hermes plugin XSafeClaw hook
ws://:18789 http://:8642 gateway + websocket
βββββββββββββββββββββ΄ββββββββββββββββββββ
β
POST /api/guard/tool-check
| Layer | Technology |
|---|---|
| Backend | Python 3.11, FastAPI, SQLAlchemy (async), uvicorn |
| Frontend | React 19, TypeScript, Vite, Tailwind CSS 4 |
| Database | SQLite (via aiosqlite) |
| Guard Model | AgentDoG (configurable base URL & model) |
| Runtimes | Local OpenClaw, Hermes Agent, and nanobot with per-session selection |
Full API docs available at http://localhost:6874/docs when running.
For detailed installation procedures, see the installation guide.
Tip
Requires Python 3.11+. Published packages include the frontend bundle. Source checkouts should run cd frontend && npm run build for the embedded backend UI, or use the Vite dev server.
# From PyPI (recommended)
pip install xsafeclaw
# From GitHub
pip install git+https://github.com/XSafeAI/XSafeClaw.git
# From source
git clone https://github.com/XSafeAI/XSafeClaw.git
cd XSafeClaw && pip install .
# Development
git clone https://github.com/XSafeAI/XSafeClaw.git
cd XSafeClaw && pip install -e ".[dev]"The Setup and Configure flows install the matching Guard integration automatically. If you are wiring runtimes manually, use the runtime-specific path below.
For OpenClaw, copy the TypeScript plugin:
cp -r plugins/safeclaw-guard ~/.openclaw/extensions/safeclaw-guardThen add to ~/.openclaw/openclaw.json:
{
"plugins": {
"entries": {
"safeclaw-guard": {
"path": "~/.openclaw/extensions/safeclaw-guard"
}
}
}
}For Hermes, copy the Python plugin to Hermes' plugin directory:
mkdir -p ~/.hermes/plugins/safeclaw-guard
cp -r plugins/safeclaw-guard-hermes/* ~/.hermes/plugins/safeclaw-guard/For nanobot, copy the Python plugin and keep the XSafeClaw package available in nanobot's uv tool environment:
mkdir -p ~/.nanobot/plugins/safeclaw-guard
cp -r plugins/safeclaw-guard-nanobot/* ~/.nanobot/plugins/safeclaw-guard/
uv tool install nanobot-ai --with-editable . --forceThe Nanobot config page does this automatically when you save: it copies the plugin, writes the hook entry to ~/.nanobot/config.json, and deploys SAFETY.md / PERMISSION.md into the nanobot workspace. The plugin injects those safety templates into every nanobot agent turn and checks tool calls through XSafeClaw Guard.
Provider, model, and API key are intentionally blank until you configure them.
For compatibility, the legacy setup endpoint still exists and creates only a skeleton config without provider/model defaults:
curl -X POST http://127.0.0.1:6874/api/system/nanobot/init-defaultXSafeClaw best-effort auto-starts installed runtimes at server boot and after setup:
- OpenClaw:
openclaw gateway start --json, defaultws://127.0.0.1:18789. - Hermes: enables the HTTP API and starts/restarts
hermes gateway, defaulthttp://127.0.0.1:8642. - nanobot: detached
nanobot gateway --port <configured-port>, default health port18790and WebSocket channelws://127.0.0.1:8765/.
Manual commands are still useful for troubleshooting:
openclaw gateway start
hermes gateway
nanobot gateway --port 18790 --verboseIf you edit runtime config files by hand, restart the affected gateway so it reloads the new settings. nanobot serve is not required for the current integration.
XSafeClaw works out of the box with sensible defaults. Copy .env.example to .env to customize:
| Variable | Default | Description |
|---|---|---|
API_PORT |
6874 |
XSafeClaw API port |
API_HOST |
0.0.0.0 |
Bind address |
DATA_DIR |
~/.xsafeclaw |
SQLite database and local state directory |
PLATFORM |
auto |
Default-instance hint: auto, openclaw, hermes, or nanobot; all discovered runtimes remain selectable |
AUTO_START_RUNTIMES |
true |
Best-effort gateway autostart for installed OpenClaw, Hermes, and nanobot runtimes |
OPENCLAW_SESSIONS_DIR |
~/.openclaw/agents/main/sessions |
OpenClaw session directory |
HERMES_HOME |
~/.hermes |
Hermes home directory |
HERMES_API_PORT |
8642 |
Hermes HTTP API port |
HERMES_API_KEY |
(empty) | Must match API_SERVER_KEY in ~/.hermes/.env |
~/.nanobot/config.json |
(created when saved in Nanobot Configure) | nanobot config, gateway, workspace, WebSocket, and XSafeClaw hook settings |
GUARD_BASE_URL / GUARD_BASE_MODEL |
AgentDoG defaults | Guard model endpoint and model ID |
OpenClaw configuration lives in ~/.openclaw/openclaw.json, Hermes in ~/.hermes/.env and ~/.hermes/config.yaml, and nanobot in ~/.nanobot/config.json. See .env.example for the full list.
Prerequisites: Python 3.11+, Node.js 18+, uv (recommended)
# Install uv project manager (if you don't already have it)
curl -LsSf https://astral.sh/uv/install.sh | sh git clone https://github.com/XSafeAI/XSafeClaw.git && cd XSafeClaw
# Backend
uv venv && uv pip install -e ".[dev]"
python run.py # http://localhost:6874, auto-reload
# Optional runtime CLIs for local testing
uv tool install nanobot-ai --with-editable . --force
openclaw gateway start
hermes gateway
nanobot gateway --port 18790 --verbose
# Frontend (separate terminal)
cd frontend && npm install && npm run dev # http://localhost:3003, HMR
# Build frontend for production
cd frontend && npm run build # outputs ignored Vite artifacts to src/xsafeclaw/static/For the repository dev loop on Linux/macOS, bash setup.sh installs backend and frontend dependencies once, and bash start.sh runs Vite on :6874 with the FastAPI backend proxied on :3022.
- OpenClaw β The personal AI assistant platform that XSafeClaw is designed to protect. OpenClaw's open plugin architecture makes our guard integration possible.
- Hermes Agent β The local Python agent runtime and multi-platform gateway now supported as a first-class XSafeClaw runtime.
- nanobot β The lightweight local agent runtime integrated through XSafeClaw's gateway, WebSocket, and Python hook support.
- AgentDoG β The diagnostic guardrail framework for AI agent safety. XSafeClaw's guard module is powered by AgentDoG's trajectory-level risk assessment and fine-grained safety taxonomy.
- ISC-Bench β Research on Internal Safety Collapse in frontier LLMs. ISC-Bench's insights into task-completion-driven safety failures have informed our red team testing design.
- AgentHazard β A benchmark for evaluating harmful behavior in computer-use agents. AgentHazard's attack taxonomy and execution-level risk categories have shaped our threat modeling.
Caution
XSafeClaw is a research tool intended for improving the safety of AI agent systems. The red team testing features are designed exclusively for defensive security research and evaluation purposes. Do not use this tool to cause harm or engage in any malicious activities.
XSafeClaw is open-sourced under the MIT License for academic research and personal use. For commercial licensing, enterprise deployment, or collaboration, please contact:
Email: xingjunma@fudan.edu.cn
We welcome contributions of all kinds β bug reports, feature requests, documentation, and code.