DashClaw
Catch destructive or expensive agent actions before they run, approve them remotely, and record every decision in a verifiable signed ledger.
- Source repo
- ucsandman/DashClaw
- Stars
- ★ 313
- Last updated
- 4d ago
- License
- MIT
- Primary language
- TypeScript
- FA score
- 65/100 · Some gaps
At a glance
- How it runs
- 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
- 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.
- 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.
- 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.
- An existing Claude Code or Codex user wiring the plugin so PreToolUse hooks fail closed and every verdict is written to an auditable ledger.
- An OpenClaw operator installing the gateway plugin so tool calls delivered by the gateway are intercepted without the agent calling a governance tool itself.
- An ops or compliance reviewer exporting a signed, hash-chained bundle of decisions to reconstruct what an automated agent did during an incident.
- 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 upThat 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-browserThe API key lands in ~/.dashclaw/instance.json; verify with:
npx dashclaw doctor
curl http://localhost:3000/api/healthFor 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/cliWire agent integrations:
dashclaw install claude
dashclaw install codex --project /path/to/repo
dashclaw install openclaw
bash scripts/install-hermes-plugin.shOr install the Claude Code plugin straight from the marketplace:
/plugin marketplace add ucsandman/DashClaw
/plugin install dashclaw@dashclawHow 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 telegramSmoke-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.pyUpgrade 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?
- 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.
- 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?
Why each dimension lost points
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.
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.
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.
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.
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.
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.
- 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.