DashClaw

Catch destructive or expensive agent actions before they run, approve them remotely, and record every decision in a verifiable signed ledger.

Stars
★ 313
Last updated
4d ago
License
MIT
Primary language
TypeScript

At a glance

How it runs
CLISelf-hosted serviceMCP server
Works with
Universal · cross-platformCodex · Claude CodeClaude.ai · OpenAI API (Partial support)
Cost
Free, no paid service needed
Setup effort
Medium · a few setup steps
You'll need
Node.js 20+Python 3.7+PostgreSQL (Docker or embedded via npx dashclaw up)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A solo developer kicking off a six-hour overnight coding-agent run who wants rm -rf, force pushes or .env reads frozen and remotely deniable from a phone.
Not a fit if
  • Teams wanting model tracing and eval dashboards
  • Teams expecting hard enforcement on bare SDK or MCP callers
  • High-security setups that must resist a same-privilege process
Source review
65/100 · Some gaps

What does this agent do, and when should you use it?

DashClaw is an approval and governance layer that sits between an AI agent deciding to call a tool and that tool actually executing. It ships as a Node 20+ server backed by PostgreSQL (started locally with npx dashclaw up), plus Node and Python SDKs, an MCP server, a CLI and a web Approvals inbox. A guard engine scores each action against declarative policies and returns one of five verdicts on the lattice allow < warn < allow_contained < require_approval < block, joining strictly with a maximum so a block can never be downgraded. Real interception is mechanical only at the specific seams DashClaw owns: the Claude Code, Codex and Hermes PreToolUse hooks, the OpenClaw gateway plugin, and dashclaw_invoke; bare SDK, REST and ordinary MCP callers stay cooperative. Pending actions can be resolved from /approvals, the CLI, a mobile PWA, Telegram or Discord, and decisions, execution claims and outcomes land in a ledger with Ed25519 receipts where the evidence path issues them. It is MIT-licensed and self-hostable, and the maintainers state plainly that the project is young, AI-maintained under a human-held charter, and not a claim of universal hard enforcement.

Every governed action passes through the guard engine, which reads the action type, raw command, declared goal and the agent's declared confidence, matches up to 20 policy types (Deploy Gate, Risk Threshold, Protected Path, Subagent Constraint and others) and applies prompt-injection scanning that is on by default; high-confidence system-override patterns force a block. A require_approval verdict freezes the action and routes it to the Approvals inbox, CLI (dashclaw approvals), the /approve PWA, Telegram or Discord, where waitForApproval() uses SSE with a polling fallback and reconciles authoritative state before resolving. On the SDK path, runGoverned() / run_governed() waits for approval, claims exactly one execution attempt under a fresh policy check, invokes the callback and reports the outcome into a five-state finality machine (pending, completed, partial, failed, lost_confirmation), with a cron sweep marking stale rows lost_confirmation. Decision records and signed exports can be re-verified with POST /api/integrity/verify without an API key. A liveness probe exercises the installed hook with a synthetic held action, a distribution-free controller calibrates interruption rate from your approve/deny history, and an optional external decision provider can tighten but never loosen local verdicts. The MCP server exposes 17 governance tools and 3 read-only resources, and every instance also serves Streamable HTTP MCP at /api/mcp.

  1. A solo developer kicking off a six-hour overnight coding-agent run who wants rm -rf, force pushes or .env reads frozen and remotely deniable from a phone.
  2. A small team running LangChain, CrewAI or AutoGen pipelines in CI or background fleets, using the Python SDK's run_governed() to put risky steps behind approval and outcome recording.
  3. An existing Claude Code or Codex user wiring the plugin so PreToolUse hooks fail closed and every verdict is written to an auditable ledger.
  4. An OpenClaw operator installing the gateway plugin so tool calls delivered by the gateway are intercepted without the agent calling a governance tool itself.
  5. An ops or compliance reviewer exporting a signed, hash-chained bundle of decisions to reconstruct what an automated agent did during an incident.
  6. A team attaching the MCP server to any stdio or HTTP MCP host so agents can query policies and approval state through tools.

How do you install or deploy this agent?

Self-hosted local start (the documented first path):

npx dashclaw up

That provisions PostgreSQL (Docker or embedded), generates secrets, mints an API key, applies migrations, starts on :3000, offers to wire Claude Code hooks and opens a signed-in browser. For a non-interactive shell (for example an AI installing on the user's behalf) use:

npx dashclaw up --yes --no-browser

The API key lands in ~/.dashclaw/instance.json; verify with:

npx dashclaw doctor
curl http://localhost:3000/api/health

For cloud deployment, use the Vercel button and set DATABASE_URL, DASHCLAW_API_KEY, ENCRYPTION_KEY, NEXTAUTH_SECRET, NEXTAUTH_URL, CRON_SECRET and DASHCLAW_LOCAL_ADMIN_PASSWORD from .env.example; the configured Vercel build runs schema migration before building.

Install SDKs and the CLI:

npm install dashclaw
pip install dashclaw
npm i -g @dashclaw/cli

Wire agent integrations:

dashclaw install claude
dashclaw install codex --project /path/to/repo
dashclaw install openclaw
bash scripts/install-hermes-plugin.sh

Or install the Claude Code plugin straight from the marketplace:

/plugin marketplace add ucsandman/DashClaw
/plugin install dashclaw@dashclaw

How do you use this agent?

Minimal Node SDK call, keeping the real effect inside the callback:

import { DashClaw } from 'dashclaw';
const claw = new DashClaw({ baseUrl: process.env.DASHCLAW_BASE_URL, apiKey: process.env.DASHCLAW_API_KEY, agentId: 'nightly-agent' });

await claw.runGoverned(
  { kind: 'shell', command: 'git push --force origin main' },
  { action_type: 'shell', declared_goal: 'Force-push the rebased branch' },
  async () => run(),
);

Python uses run_governed(). Point any MCP client at the server:

{ "mcpServers": { "dashclaw": { "command": "npx", "args": ["@dashclaw/mcp-server"],
  "env": { "DASHCLAW_URL": "https://your-dashclaw.vercel.app", "DASHCLAW_API_KEY": "oc_live_xxx" } } } }

Approve and operate from the terminal:

dashclaw approvals
dashclaw approve <id>
dashclaw install telegram

Smoke-test that the Claude Code hook actually fires:

echo '{"tool_name":"Bash","tool_input":{"command":"echo hello"},"tool_use_id":"t1","session_id":"smoke"}' | python .claude/hooks/dashclaw_pretool.py

Upgrade order matters: deploy the matching schema and server before upgrading SDK helpers that use execution-claim protocol 1, then set DASHCLAW_REQUIRE_EXECUTION_CLAIMS=1 to reject legacy responses.

What are this agent's strengths and limitations?

Pros
  • Honest enforcement taxonomy: a per-runtime table separates the mechanical seams (Claude Code/Codex/Hermes hooks, OpenClaw gateway, dashclaw_invoke) from cooperative SDK, REST and MCP callers.
  • Remote approval is broad and practical, with /approvals, CLI, mobile PWA, Telegram and Discord plus target-scoped, expiring, revocable standing grants instead of silence.
  • Evidence is independently checkable: Ed25519 receipts, a signed hash-chained export, and POST /api/integrity/verify usable without an API key.
  • The default policy pack is deliberately narrow (catastrophe-only) because the docs document an 18-day blackout caused by over-firing defaults.
  • A liveness probe judges enforcement by execution rather than by ledger entries, catching silently skipped hooks that still logged plausible decisions.
Limitations
  • Bare SDK, REST API and ordinary MCP integrations remain cooperative; an uncooperative caller is not blocked.
  • The hook runs at the agent's own privilege level, so isolation requires deployment-side measures such as a container, separate OS user or read-only hook path.
  • The API surface is tiered (43 stable, 18 beta, 75 experimental) and can change; upgrades require deploying the schema and server before the SDK.
  • Requires PostgreSQL and a set of generated secrets, so self-hosting is a multi-step setup rather than a zero-dependency install.
  • First commit was February 2026 and external production use is described as early; it is dogfood-proven, not battle-tested at scale.

How does this agent compare with similar options?

The README names no specific competitor. It scopes itself against three categories of alternative: local runtime permission prompts, which serve the operator sitting at the keyboard while DashClaw targets unattended remote and async approval; general tracing and evaluation products, which it explicitly says it is not; and general agent platforms with calendar, CRM, messaging or RAG tool suites, which the v5.0.0 cull removed and a CI surface-budget brake prevents from regrowing.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
DashClaw This agent 65 · Some gaps CLIFree ★ 313 4d ago TypeScript Codex · Claude Code
Flow-Like 55 · Major gaps Desktop appFreemium ★ 968 today Rust —
Heym 46 · Major gaps Self-hosted serviceFree + model costs ★ 1.3k today Python Codex · Claude.ai
Preloop 84 · Good — ★ 82 today Python Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
65/ 100 5-point scale 3.3 / 5
Trust 17/29
Reliability 8/14
Adaptability 15/18
Convention 13/18
Effectiveness 7/13
Verifiability 5/8
Why each dimension lost points
Trust17 / 29 · 2.9/5

Evidence shows real least-privilege design: default-deny /api/* middleware, public-route allowlist, admin/member gates, separation of duties (SELF_APPROVAL_FORBIDDEN), SSRF DNS pinning and private-IP rejection, so least_privilege scores 2; deducted because hooks run at the agent's own privilege and can be tampered by a same-privilege process, which the README itself admits. user_confirmation scores 3: remote approvals, fail-closed interception, non-downgradable block, and previewable/revocable standing grants are well evidenced. data_flow_transparency scores 2: docs describe guard decisions, DLP redaction, and evidence-graded intent, but actual data flows (e.g., LLM/third-party calls) are only partially disclosed. sensitive_data_handling scores 2: DLP scanning, AES-GCM+AAD, masking, and secrets excluded from bundles exist, but historical audits exposed plaintext leaks and unauthenticated CBC, showing residual surface even if fixed. dependency_security scores 1: dependencies use floating ^ ranges, the xlsx vulnerability is 'accepted risk' rather than fixed, and control relies on Dependabot/overrides without proof of ongoing mitigation. external_effects scores 2: explicitly admits external effects are not exactly-once and require reconciliation; runGoverned does not repeat callbacks, honest but not thorough. rollback scores 1: observe mode, env rollback switches, immutable outcomes and parent_action_id recovery exist, but no user-facing one-click rollback/undo of executed effects is evidenced. source_attribution scores 1: MIT and author field present, but publisher identity is unverified and there is no signed release or provenance proof beyond metadata.

Reliability8 / 14 · 2.9/5

self_consistency scores 2: README and SECURITY docs agree on enforcement boundary, claim protocol, and upgrade order, with self-corrections (e.g., 'no exactly-once promise'), but the docs are very long with dated history and drift risk. dependency_availability scores 1: requires Node 20+, Postgres, optional Redis/Upstash, Docker or embedded PG, and CI installs cli/mcp-server deps separately; evidence for ordinary-environment fit is thin. failure_messages scores 2: docs describe 409 outcome already set, SELF_APPROVAL_FORBIDDEN, not_approved/expired/hash_mismatch errors, but these are assertions without a complete error catalog.

Adaptability15 / 18 · 4.2/5

audience_and_scenarios scores 3: explicitly targets solo devs/small teams running long unattended sessions (overnight, CI, background fleets) with concrete scenarios. capability_boundaries scores 3: a dedicated 'What DashClaw is not' section rules out general tracing/platform/hard isolation, honestly drawn. trigger_precision scores 2: decision lattice allow<warn<allow_contained<require_approval<block, join=max, absolute block are clear, but prompt-injection scanning and calibration thresholds are asserted without detailed precision evidence. environment_fit scores 2: supports Claude Code/Codex/Hermes/OpenClaw/MCP/Node/Python/REST, but mechanical enforcement is limited to a few seams and the rest is cooperative, so fit is uneven.

Convention13 / 18 · 3.6/5

information_architecture scores 2: README is well structured with anchors and separates THESIS/MAINTAINER/maintainer-log, but the single file is extremely long and dense. install_notes scores 2: npx dashclaw up, Vercel deploy, and per-runtime install commands are present, but Docker/Postgres and multi-package installs make steps heavy. naming_stability scores 1: version 5.38.0 with many historical version references (v2.6/v4.63/v5.20) and a large, frequently changing API surface (41/61 methods, 136 routes) show insufficient stability evidence. examples_and_faq scores 2: examples/, QUICK-START, integration guides and snippets exist, but FAQ-style content is scattered. known_limitations scores 3: a dedicated section lists non-universal enforcement, non-tamper-proofing, non-battle-tested scale, and non-exactly-once effects, disclosing limits thoroughly. license scores 3: full MIT text in LICENSE and MIT in package.json, consistent. versioning_changelog scores 2: CHANGELOG references, maintainer log, and version-sync scripts exist, but no complete changelog file content is shown. maintenance_responsibility scores 2: MAINTAINER.md charter, AI maintainer under human-held charter, and public maintainer log make responsibility clear; deducted because publisher identity is unverified.

Effectiveness7 / 13 · 2.7/5

output_usability scores 2: approvals inbox, CLI, PWA, Telegram/Discord channels, decision records and signed receipts are usable, but receipts only prove signed contents, not external effects, limiting output utility. marginal_value scores 2: provides remote approval and audit trail for unattended runs, an increment over local permission prompts, but cooperative integrations require caller cooperation, weakening the increment. cost_benefit scores 1: requires self-hosted Postgres, multiple secrets, and multi-runtime hook maintenance at high cost while enforcement is limited to a few seams, so benefit/cost evidence is insufficient.

Verifiability5 / 8 · 3.1/5

claim_traceability scores 2: many README claims link to docs (enforcement-boundary, durable-execution-finality, maintainer log) and are traceable, but some performance/calibration claims are bare assertions. cross_source_corroboration scores 2: README, SECURITY.md, SECURITY_FIXES, and CI workflows corroborate security fixes and tests, but all are self-reported with no independent third-party verification. fact_inference_separation scores 2: docs distinguish mechanical vs cooperative enforcement, receipt scope, and client-reported diagnostics vs attestation, separating fact from inference well, though marketing phrasing ('catches it before it runs') remains strong.

Risks and how to mitigate them
  • Hooks run at the agent's own privilege; a same-privilege process can tamper with or disable governance. Real isolation (container, separate OS user, read-only hook path) is a deployment responsibility.
  • Mechanical enforcement is limited to Claude Code/Codex/Hermes hooks, the OpenClaw gateway, and dashclaw_invoke; bare SDK/API/MCP callers are cooperative and governance fails if they ignore the verdict.
  • External effects are not exactly-once; if a claim or completion ack is lost, manual reconciliation is required and ledger idempotency cannot guarantee a single external effect.
  • Dependencies use floating ^ ranges and the xlsx vulnerability is 'accepted risk' rather than fixed; run npm audit and assess independently.
  • Publisher identity is unverified with no signed release or provenance proof; verify source and integrity before installing.
  • Docs are extremely long with dated history and version references, creating drift risk; treat the current revision's code as authoritative.
Evidence confidence: Low Reviewed Oct 29, 2026 Reviewed revision 704824de5f5f
See the full review method →

FAQ

Will it fully prevent a dangerous agent action?
Only at specific seams. Claude Code, Codex and Hermes PreToolUse hooks, the OpenClaw gateway and dashclaw_invoke are fail-closed; bare SDK, REST and ordinary MCP callers are cooperative and must honor the verdict themselves. Even at a hook, DashClaw runs at the agent's privilege level, so real isolation depends on a container, a separate OS user or a read-only hook path.
What infrastructure do I need to run it?
The local path needs Docker (or uses embedded Postgres) and lets npx dashclaw up generate secrets and mint an API key. The cloud path needs DATABASE_URL, DASHCLAW_API_KEY, ENCRYPTION_KEY, NEXTAUTH_SECRET, NEXTAUTH_URL, CRON_SECRET and related variables from .env.example, plus a PostgreSQL provider such as Neon.
What happens if an approval wait or an outcome report is lost?
Approved actions carry a five-state finality (pending, completed, partial, failed, lost_confirmation). POST /api/actions/[actionId]/outcome is one-shot and later posts return 409; a cron sweep marks stale rows lost_confirmation, which means completion is unknown rather than that nothing happened. If an execution claim or completion ack is lost, the helper does not repeat the callback — reconcile the external system or use its idempotency primitive before retrying.
Is it tied to a particular model vendor?
No. DashClaw governs the tool-call seam, not the model, and documents Claude Code, Codex, Hermes, OpenClaw, MCP hosts, Node and Python SDKs and plain REST. What differs by path is enforcement strength: hook and gateway integrations intercept mechanically, the rest are cooperative.
Can I run it in observe mode first?
Yes. Pass --observe or set DASHCLAW_HOOK_MODE=observe to log without blocking; /approvals and /decisions show a red banner, unenforced verdicts render as 'Logged, not enforced', and PostToolUse adds an executed_despite witness stamp when a gated action ran anyway. Note that narrowing DASHCLAW_GOVERNED_CATEGORIES makes excluded tool calls absent from /decisions entirely, which since v5.20 raises a governance-scope-narrowed signal.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents