DashClaw: AI Agent Governance for Unattended Runs
DashClaw is a fail-closed approval layer that freezes a coding agent's risky tool calls, like rm -rf or a force-push, before they execute, then pages you to approve or deny from anywhere. Reach for it if you run agents unattended for hours at a stretch and need someone off-keyboard to catch a bad command; skip it if you're always at the terminal, since Claude Code and Codex already give you a free prompt for that case.
The Challenge of Unattended AI Agents
AI coding agents such as Claude Code and Codex include a permission prompt intended for the person monitoring the display, yet this prompt becomes ineffective the instant you are absent. The README highlights the actual problem: when a solo developer or small team initiates a one-to-six-hour unattended operation — like an overnight session, a CI agent, or a background fleet — against live repositories and infrastructure, they cannot monitor every tool invocation. Should the agent's logic lead it to execute `git push --force origin main` or a `DROP TABLE` command at 2am, an on-screen prompt requiring keyboard input would simply halt the process until dawn; no one would be present to intervene. DashClaw's internal maintainer log documents the tool intercepting the maintainer's own shell command during verification — specifically, it was extracting an API key from `.env.local` and preparing to transmit it. This pinpoints the exact vulnerability: it's not merely an abstract "agents need oversight," but rather the reality that integrated prompts inherently demand your physical attendance, and extended unattended operations are precisely when you are absent.
What DashClaw Provides
DashClaw is a governance runtime that sits between an AI coding agent's decision to call a tool and the tool actually running, scoring each action against your policies first. It ships as a local server started with `npx dashclaw up`, plus hooks for Claude Code, Codex, and Hermes, an MCP server, and Node and Python SDKs for everything else. Every decision lands in a replayable, signed ledger.
Core Capabilities for Agent Control
- ✓Fail-closed intercept: a blocked call exits the hook with code 2, so the tool never actually runs — the block happens before execution, not after.
- ✓One-click remote approval: resolve a frozen action via the CLI, a phone PWA, Telegram, Discord, or the `/approvals` inbox, without requiring use of the keyboard.
- ✓The audit trail is tamper-evident, with Ed25519-signed receipts and a replayable decision ledger; users can check a receipt via `POST /api/integrity/verify` without an API key, as the signing key is published through JWKS.
- ✓Calibrated interruptions: A distribution-free controller uses your approve/deny history to establish a proven false-interruption bound, replacing any guessed threshold.
- ✓An enforcement liveness probe functions by driving a synthetic held action along the real hook path. Its verdict is determined by confirming the action's actual execution, instead of relying on ledger readings.
- ✓Prompt-injection scanning is active by default. At guard time, a `block` is forced by high-confidence system-override patterns, and a `warn` is raised by weaker ones.
- ✓Declarative policy builder: ten pre-built safety switches — Deploy Gate, Risk Threshold, Rate Limiter, Evidence Required, Protected Path, Subagent Constraint, and others — across 15 guard policy types, plus an AI generator and YAML import.
- ✓Multi-runtime coverage: Claude Code, Codex, Hermes, OpenClaw, MCP, Node and Python SDKs, and plain REST all land on the same guard engine and ledger.
Who Benefits from DashClaw
DashClaw is aimed narrowly at either a single developer or a modest team executing lengthy, unsupervised coding-agent sessions — overnight runs, CI agents, background fleets — against a real repository and real infrastructure, per the README. If you always work at the keyboard and can eyeball every tool call yourself, the native prompts in Claude Code or Codex already cover you for free and DashClaw adds setup you don't need. It fits better once a run is long enough, or has enough agents in it, that you can't watch continuously.
Quick Start and Self-Hosting
The fastest path is one command: `npx dashclaw up`. It provisions Postgres (Docker or embedded), generates secrets, mints an API key, applies migrations, starts the server on port 3000, offers to wire up Claude Code hooks, and opens your browser already signed in — no account required to reach your first caught action. To wire a specific coding-agent plugin afterward: `npm i -g @dashclaw/cli`, then `dashclaw install claude` (which wires `~/.claude/settings.json` and defaults fresh installs to enforce mode), `dashclaw install codex --project /path/to/repo`, or `bash scripts/install-hermes-plugin.sh` for Hermes (a `.ps1` variant exists for Windows). For a $0 cloud deploy, pair Vercel's free tier with Neon's free Postgres tier and fill in the environment variables from `.env.example`; the schema migration runs during the build. If you want to see the Approvals inbox before deploying anything, `hosted.dashclaw.io/connect` spins up a capped trial workspace in the browser, and you can later export that workspace and run `dashclaw import <bundle.json>` against your own instance — policies, decisions, history, and agents carry over, but API keys and secret values never ride the export bundle.
Strengths
- ✓The block is verified, not just claimed: a liveness probe re-drives a synthetic action through the real hook path and checks whether it actually executed, so a stale or silently-broken hook doesn't render green.
- ✓Approval isn't tied to a laptop — the same frozen action can be resolved from the CLI, the mobile PWA, Telegram, or Discord.
- ✓The maintainer publishes its own failure log in the open: an 18-day stretch with the default policy pack disabled, and a v4.72.1 timeout bug that silently let blocked calls through while the ledger still looked clean. That kind of honesty is rare in a security tool's own docs.
- ✓MIT-licensed and $0 to try — one local command, or a Vercel-plus-Neon free-tier deploy.
What DashClaw Is Not
- △Enforcement is mechanically real only at specific seams — the Claude Code, Codex, and Hermes hooks, the OpenClaw gateway, and `dashclaw_invoke`. Everywhere else (the bare SDK, the REST API, most MCP callers, desktop chat) it's cooperative: the caller has to choose to consult the guard decision, DashClaw doesn't force it.
- △It's early: the README states the first commit was in February 2026, and the project describes itself as proven by continuous dogfood rather than a large install base.
- △It isn't an agent platform — no calendar, CRM, messaging, or RAG tools — so it only governs actions, it doesn't help an agent get anything done.
- △It isn't an observability tool. If what you actually want is traces and dashboards of what an agent already did, DashClaw's pre-execution block doesn't give you that; pair it with something like LangSmith or Langfuse instead.
DashClaw vs. Other Agent Tools
Frequently Asked Questions
DashClaw catches destructive shell and database commands before they execute — the README lists a working-directory `rm -rf`, a `DROP TABLE` against a live database, a `git push --force origin main`, and a case of reading `.env` with intent to exfiltrate it. Each one gets frozen at the hook seam instead of running.
DashClaw can be self-hosted for $0: run `npx dashclaw up` locally, which provisions Postgres and starts the server on port 3000, or deploy it by pairing Vercel's free tier with Neon's free Postgres tier.
DashClaw ships hooks for Claude Code, Codex, and Hermes, a gateway plugin for OpenClaw, an MCP server, and Node and Python SDKs. The Python SDK adds CrewAI and AutoGen integrations, and LangChain agents can reach DashClaw through that same SDK.
DashClaw does not claim universal hard enforcement, and the README says it never will. Enforcement is mechanically real only at specific seams — the Claude Code, Codex, and Hermes hooks, the OpenClaw gateway, and `dashclaw_invoke` — while the bare SDK, REST API, and most MCP callers rely on cooperative enforcement instead.
DashClaw is released under the MIT license and hosted publicly on GitHub, where it currently has 288 stars and 49 forks.
DashClaw is early-stage: the README states its first commit was in February 2026 and describes the project as proven by continuous dogfood rather than a large install base, with incidents like an 18-day stretch in June 2026 documented openly in the maintainer log.
Best use cases
- •Kicking off an overnight coding-agent run against a real repo and waking up to a decision ledger instead of a surprise force-push.
- •Running CI agents or background agent fleets where nobody is watching every tool call in real time.
- •Wiring a Claude Code, Codex, or Hermes session so destructive Bash, Edit, Write, MultiEdit, or MCP calls get frozen before they execute.
- •Approving or denying a frozen action from a phone via the PWA, Telegram, or Discord when you're away from your desk.
How to use
Once running, the SDK loop is four calls. Call `guard()` with the real action (a shell command, a file write) and DashClaw's server classifies risk from that evidence — evidence can only raise the risk score, never lower it. Call `createAction()` to log a declared goal. If the verdict comes back `require_approval`, `waitForApproval()` blocks until a human resolves it from the inbox, CLI, phone PWA, Telegram, or Discord — grants are single-use and bound to that exact action. Finally call `reportActionSuccess()` or `reportActionFailure()` to close the record; the first outcome wins and a retry after that gets a 409. Inside Claude Code, Codex, and Hermes the hook seam runs this loop for you automatically — Bash, Edit, Write, MultiEdit, sub-agent spawns, and every `mcp__*` call all pass through a fail-closed PreToolUse check. Fresh installs start in enforce mode; add `--observe` or set `DASHCLAW_HOOK_MODE=observe` to log without blocking. You can confirm the hook is actually wired by piping a sample tool-call payload into `.claude/hooks/dashclaw_pretool.py` and checking the response.
Related repositories
Want a second opinion on DashClaw?
Ask an AI that can read this page — one click and you get its take on DashClaw.
