DashClaw is the policy firewall for AI agents.
DashClaw governs the moment agent intent becomes real-world action. Enforce policies, require human approval, and record verifiable evidence in one runtime.
Works with OpenAI, Claude, CrewAI, LangChain, AutoGen, OpenClaw, or any custom agent.
MIT Licensed. Self-host in seconds.

DashClaw governs the moment where agent intent becomes real-world action.
This interception is where trust is created.
await deleteFiles({
path: "/prod/data"
});
// No check. No record.
// No way back.const { decision } = await dc.guard({
action: "delete_files",
resource: "/prod/data"
});
if (decision === "allow") {
await deleteFiles({ path: "/prod/data" });
}Agents retain autonomy.
Organizations retain control.
DashClaw intercepts actions before they reach real-world systems.
Developers need governance over agent decisions.
Not just logs. Not just traces. A runtime that governs the decision itself.
DashClaw is built around five primitives that form a decision runtime for autonomous systems.
Agents declare what they want to do.
Evaluate policies before agents act.
Pause risky decisions for human review.
The governed decision is executed.
A signed replay is recorded for audit.
Governance logic belongs in the runtime, not hardcoded in your agents.
DashClaw is the governance layer for existing agent frameworks.
from dashclaw import DashClaw
import os
claw = DashClaw(
base_url=os.environ["DASHCLAW_BASE_URL"],
api_key=os.environ["DASHCLAW_API_KEY"],
agent_id="my-agent"
)
# Intercept tool execution
decision = claw.guard(
action_type="deploy",
risk_score=82
)
if decision == "allowed":
run_agent_tool()# Wrap sensitive agent tasks
decision = claw.guard(
action_type="external_api_call",
provider="stripe",
risk_score=88
)
if decision == "allowed":
crew.kickoff()import { DashClaw } from 'dashclaw'
const claw = new DashClaw({
baseUrl: process.env.DASHCLAW_BASE_URL,
apiKey: process.env.DASHCLAW_API_KEY,
agentId: 'my-agent'
})
// Guard before calling the tool
const { decision } = await claw.guard({
actionType: "deploy",
riskScore: 90
})
if (decision === 'allowed') {
await openai.chat.completions.create(...)
}# .claude/hooks/dashclaw_pretool.py
# Governs Bash, Edit, Write, MultiEdit
# No pip installs required
import json, sys, urllib.request, os
payload = json.loads(sys.stdin.read())
tool = payload.get("tool_name", "")
if tool not in ["Bash","Edit","Write","MultiEdit"]:
sys.exit(0) # not governed
# Guard check via DashClaw API
# block/approve/allow based on policyZero-dependency Node.js and Python clients. Adding governance requires only a small wrapper around risky actions.
Practical scenarios where decision governance creates trust.
Intercept deploy commands from agents and require approval when risk thresholds are exceeded.
Agents interacting with third-party APIs can be governed with policies.
Track assumptions agents rely on and detect when they become invalid. DashClaw records agent assumptions and decision context.
When assumptions diverge from reality, the system flags drift immediately.
Every governed action generates structured evidence records ready for compliance and review.
{
"agent": "deployment-bot",
"action": "deploy",
"riskScore": 85,
"policy": "production_guard",
"approval": "granted"
}Once decisions are governed, DashClaw provides the operational visibility required to run agent fleets at scale.
Real-time control tower for fleet posture and active interventions.
Visual causal chains that explain exactly why an agent chose an action.
Semantic guardrails that evolve with your organization without code changes.
Automated detection of autonomy spikes, drift, and failure loops.
Approve or deny agent actions from the terminal. Works with Claude Code, Codex, and any terminal-first workflow.
Govern Claude Code tool calls via lifecycle hooks. No SDK instrumentation required.
Control-level gap analysis with remediation priorities.
Run tests against all active guard policies.
Generate audit-ready evidence from live behavior.
Automatic detection of autonomy breaches and logic drift.
Agent taking too many actions without human checkpoints
Critical actions without sufficient review
Same action type failing multiple times
Open loops unresolved past their expected timeline
Assumptions becoming stale or contradicted by outcomes
Assumptions not validated within expected timeframe
Actions stuck in running state for over 4 hours
DashClaw provides multiple integration surfaces: SDK instrumentation, a CLI approval channel, and Claude Code lifecycle hooks.
Define, test, and enforce guard policies. Centralize governance logic.
claw.guard({ type: "deploy", risk: 85 })Immutable record of every agent intent and outcome. Prove accountability.
claw.createAction({ goal: "Database cleanup" })Automatic detection of risky behavior patterns across your agent fleet.
signal: autonomy_spike detected for agent-1
Once decisions are governed, Mission Control provides the operational visibility required to run fleets at scale.
Live operational data:

DashClaw lets agents move fast without giving up control. Intercept risky actions. Require approval when needed. Prove every decision afterward.