TopGit
GitHub Repo Review

DashClaw: AI Agent Governance for Unattended Runs

ucsandman/DashClaw
DTopGit review image for ucsandman/DashClaw
Review by Topgit.dev for ucsandman/DashClaw, with GitHub repository stats and README context.
Quick verdict

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.

Stars
★ 318
Forks
⑂ 53
Language
TypeScript
License
MIT
Topic
AI Tools
Updated
Nov 2026
Homepage
GitHub

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.
How this repository's GitHub stars have grown over time. Source: star-history.com.View the star history ↗

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

LangSmith — an observability platform that records what an agent did after the fact, for tracing and debugging; DashClaw instead blocks the action before it runs, so the two answer different questions and can be run side by side.Langfuse — same after-the-fact tracing category as LangSmith, useful for evals and prompt debugging, but with no mechanism to stop a destructive command before it executes. ↗

Frequently Asked Questions

What kind of actions can DashClaw prevent?

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.

Can DashClaw be self-hosted?

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.

What AI agent runtimes and frameworks does DashClaw support?

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.

Does DashClaw provide universal hard enforcement for all agent actions?

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.

Is DashClaw open source?

DashClaw is released under the MIT license and hosted publicly on GitHub, where it currently has 288 stars and 49 forks.

What is the maturity level of DashClaw?

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

Source & attribution

Based on the ucsandman/DashClaw GitHub repository (README, MIT license, 288 stars, 49 forks).

GitHub data · last synced Aug 6, 2026Reviewed by Henry
← Back to TopGit

Want a second opinion on DashClaw?

Ask an AI that can read this page — one click and you get its take on DashClaw.

GitHub