Open-source AI governance runtime

Intercept agent actions before they reach production.

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.

Agent Intent
DashClaw Guard
Production System

Decision Interception Demo

DashClaw decision interception in action
MIT Licensed
Self-hosted
Zero-dependency SDK
Node + Python

The interception layer for AI agents

DashClaw governs the moment where agent intent becomes real-world action.

This interception is where trust is created.

Agent Intent
DashClaw Guard
ALLOW
Production
BLOCK
without DashClaw
await deleteFiles({
  path: "/prod/data"
});
// No check. No record.
// No way back.
with DashClaw
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 sits between agents and the systems they control

DashClaw intercepts actions before they reach real-world systems.

Autonomous Actor
AI Agent
OpenAI · Claude · CrewAI · OpenClaw
DashClaw Runtime
Policy Engine
Approval Routing
Evidence Ledger
Real-world Targets
External Systems
GitHub · APIs · Databases · Infrastructure

AI agents introduce a new runtime problem

Traditional Software
  • Deterministic code paths
  • Predictable outputs
  • Traceable call stacks
  • Debuggers work
AI Agents
  • Actions generated from goals
  • Non-deterministic outputs
  • No call stack to trace
  • Debuggers are not enough

Developers need governance over agent decisions.

Not just logs. Not just traces. A runtime that governs the decision itself.

The Decision Runtime

DashClaw is built around five primitives that form a decision runtime for autonomous systems.

Agent Intent
Sync local data to Neon dashboard
Actor: moltfire
Confidence: 50%

Intent

Agents declare what they want to do.

Guard Policyactive
Block if risk > 80
Risk >= 80 → block
gp_0423d9749de847b8be38ff3a

Guard

Evaluate policies before agents act.

Human Approvalpending
REVIEW: data alerting
Agent: api-monitor
96% RISK

Approval

Pause risky decisions for human review.

Executionsuccess
ACTION SUCCESSFUL
Synced 80 rows + 6 calendar events
Duration: 6.25s

Action

The governed decision is executed.

Decision Proofverified
Cryptographically Signed
act_1386c4ee-2529-4c79-9455
dc_sig_v1_eyJpZCI6I...

Evidence

A signed replay is recorded for audit.

Governance logic belongs in the runtime, not hardcoded in your agents.

Works with your agent stack

DashClaw is the governance layer for existing agent frameworks.

LangChain
Python tool guard
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()
CrewAI
Agent task guard
# Wrap sensitive agent tasks
decision = claw.guard(
    action_type="external_api_call",
    provider="stripe",
    risk_score=88
)

if decision == "allowed":
    crew.kickoff()
OpenAI Tools
Node.js function guard
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 Code
PreToolUse hook
# .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 policy
One SDK. Full decision infrastructure.

Get governance in 60 seconds

Zero-dependency Node.js and Python clients. Adding governance requires only a small wrapper around risky actions.

View full SDK docs
SDK Example
// 1. Initialize DashClaw
const claw = new DashClaw()
// 2. Intercept before you act
const { decision } = await claw.guard({
actionType: 'deploy',
riskScore: 85
})
// 3. Follow the decision
if (decision === 'allowed') {
// execute real-world action
}

What developers use DashClaw for

Practical scenarios where decision governance creates trust.

Prevent risky deployments

Intercept deploy commands from agents and require approval when risk thresholds are exceeded.

const decision = await claw.guard({
actionType: "deploy",
environment: "production",
riskScore: 92
})
  • • Request human approval
  • • Pause execution
  • • Record evidence for audit

Control autonomous API usage

Agents interacting with third-party APIs can be governed with policies.

await claw.guard({
actionType: "external_api_call",
provider: "stripe",
amount: 2000
})
  • • Limit spending thresholds
  • • Block dangerous actions
  • • Trigger approval workflows

Detect agent reasoning drift

Track assumptions agents rely on and detect when they become invalid. DashClaw records agent assumptions and decision context.

Assumptions DivergenceDRIFT DETECTED
Logic Baselinev1.2.0
Current ContextUnverified state

When assumptions diverge from reality, the system flags drift immediately.

Produce audit trails

Every governed action generates structured evidence records ready for compliance and review.

{
  "agent": "deployment-bot",
  "action": "deploy",
  "riskScore": 85,
  "policy": "production_guard",
  "approval": "granted"
}
  • • Compliance reporting
  • • Debugging agent failures
  • • Governance review

When governance becomes operations

Once decisions are governed, DashClaw provides the operational visibility required to run agent fleets at scale.

Mission Control

Real-time control tower for fleet posture and active interventions.

Decision Replay

Visual causal chains that explain exactly why an agent chose an action.

Policy Engine

Semantic guardrails that evolve with your organization without code changes.

Risk Signals

Automated detection of autonomy spikes, drift, and failure loops.

CLI Approval Channel

Approve or deny agent actions from the terminal. Works with Claude Code, Codex, and any terminal-first workflow.

Claude Code Hooks

Govern Claude Code tool calls via lifecycle hooks. No SDK instrumentation required.

AI Governance Suite

Every governed decision produces audit-ready evidence.

SOC 2ISO 27001GDPRNIST AI RMF

Compliance Engine

Control-level gap analysis with remediation priorities.

Policy Testing

Run tests against all active guard policies.

Audit Evidence

Generate audit-ready evidence from live behavior.

Detect when agent autonomy goes wrong

Automatic detection of autonomy breaches and logic drift.

Autonomy Spike

Agent taking too many actions without human checkpoints

High Impact, Low Oversight

Critical actions without sufficient review

Repeated Failures

Same action type failing multiple times

Stale Loop

Open loops unresolved past their expected timeline

Assumption Drift

Assumptions becoming stale or contradicted by outcomes

Stale Assumption

Assumptions not validated within expected timeframe

Stale Running Action

Actions stuck in running state for over 4 hours

Integration Surfaces

DashClaw provides multiple integration surfaces: SDK instrumentation, a CLI approval channel, and Claude Code lifecycle hooks.

Policy & Guard

Define, test, and enforce guard policies. Centralize governance logic.

claw.guard({ type: "deploy", risk: 85 })

Decision Ledger

Immutable record of every agent intent and outcome. Prove accountability.

claw.createAction({ goal: "Database cleanup" })

Risk Monitoring

Automatic detection of risky behavior patterns across your agent fleet.

signal: autonomy_spike detected for agent-1

Operational visibility for agent fleets

Once decisions are governed, Mission Control provides the operational visibility required to run fleets at scale.

Live operational data:

  • live actions
  • policy decisions
  • pending approvals
  • integrity signals
  • agent health
DashClaw Mission Control - strategic overview of your agent fleet

Run agents with permissioned autonomy.

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