Decision Infrastructure for AI Agents

The policy firewall for AI agents.

DashClaw intercepts agent actions before they reach the real world. Enforce policies, require human approval, and record verifiable evidence in one open source runtime.

Works with Claude Code, Codex, Hermes Agent, Claude Managed Agents, OpenAI, LangChain, CrewAI, AutoGen, Gemini CLI, and any custom agent.

MIT licensedSelf hostedNo per seat pricingNo usage capsYour data stays on your infrastructure

For teams running AI agents where the cost of a bad action is real.

Live demo, real demo endpoints

Try a real governance decision

Pick an action, hit Evaluate, and watch DashClaw enforce policy in real time. Every call hits the same governance runtime that ships to your instance.

Pick an action to evaluate
SDK call
await claw.guard({
  agent_id: 'openai-deployer-1',
  action_type: 'deploy',
  risk_score: 85,
  declared_goal: 'Deploy auth-service v2.1 to production with new session token rotation.',
});
Governance result

Pick an action and click Evaluate. The result will appear here, including the matched policy, the risk score, and what a human approver would see.

Guard decisions are live against the demo deployment. Approval clicks resolve locally so visitors can explore the flow without an account; your own instance routes them to /api/actions/:id/approve.

Works with

Claude Code HooksOpenClaw PluginMCP ServerPlatform SkillNode SDKPython SDKREST APICLIDiscord ApprovalsTelegram Approvals

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.

MCP Server
Zero-code governance
// Add to claude_desktop_config.json
// or .mcp.json for Claude Code
{
  "mcpServers": {
    "dashclaw": {
      "command": "npx",
      "args": ["@dashclaw/mcp-server"],
      "env": {
        "DASHCLAW_URL": "https://your-instance.vercel.app",
        "DASHCLAW_API_KEY": "oc_live_..."
      }
    }
  }
}
// 23 governance tools + 4 resources
// No SDK. No code changes.
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
Codex
PreToolUse hook + MCP
# One command wires it all into ~/.codex/config.toml
$ dashclaw install codex --project .

# Managed block written to ~/.codex/config.toml:
approval_policy = "on-request"

[mcp_servers.dashclaw]
command = "python"
args = [".../dashclaw-mcp.js", "--agent-id", "codex"]

[[hooks.PreToolUse]]
matcher = "Bash|Edit|Write|MultiEdit"
[[hooks.PreToolUse.hooks]]
type = "command"
command = "python ~/.codex/hooks/dashclaw/dashclaw_pretool.py"

# Same hooks. Same audit ledger. agent_id = codex.
Hermes Agent
8 lifecycle hooks + live ingest
# One install script wires 8 hooks into ~/.hermes/config.yaml
$ bash scripts/install-hermes-plugin.sh

# Managed block written to ~/.hermes/config.yaml:
hooks:
  pre_tool_call:  [...]  # guard / block / require_approval
  post_tool_call: [...]  # outcome recording
  pre_llm_call:   [...]  # per-turn policy + approval context injection
  post_llm_call:  [...]  # live ingest to /api/code-sessions/ingest-live
  on_session_start: [...] # cache warm
  on_session_end:   [...] # finalize: true -> optimizer + alerts pass
  transform_tool_result: [...] # redact API keys, JWTs, PEM blocks
  subagent_stop:    [...] # delegate_task ROI tracking

# Per-turn cost attribution. agent_id = hermes.
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

Three patterns that come up in every production agent stack.

Stop runaway deployments

One approval before production, full audit trail after.

await claw.guard({
  agent_id: 'deploy-bot',
  action_type: 'deploy',
  risk_score: 92,
  declared_goal: 'Ship auth-service v2.1 to prod',
});
What DashClaw did

Matched the production_deploy policy, paused the action, routed to the on-call engineer, recorded the approval.

Every governed action also lands in the evidence ledger, ready for compliance review without a separate audit pipeline.

When governance becomes operations

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

Mission Control

Live operational visibility for the agent fleet. See what is running, what was decided, and what is waiting on a human.

  • Live fleet posture and active interventions
  • Decision replay with the full causal chain
  • Real-time SSE event stream

Policy Engine

Semantic guardrails that decide allow, block, or require approval before the action reaches the real world.

  • Guard primitive with policy testing
  • Risk signals for autonomy spikes and failure loops
  • Assumption drift detection with z-score baselines

Approval Surfaces

Approvers resolve pending actions wherever they already work, against the same governance endpoint. Claude Code lifecycle hooks add an inline prompt path for terminal workflows.

  • Dashboard inbox at /approvals
  • CLI with dashclaw approve and approvals
  • Mobile PWA at /approve
  • Discord DM with inline Approve and Deny buttons
  • Telegram inline Approve and Reject buttons
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

How DashClaw compares

Observability tools record what happened. DashClaw governs what is allowed to happen.

DimensionTracing tools (LangSmith, Langfuse)DashClaw
When it actsAfter the actionBefore the action
Core primitiveLog or traceGuard and policy
Human in the loopAdd onFirst class
Compliance evidenceTrace exportAction level, policy and approver bound
Self hostAvailableAvailable, MIT, no paid tier required

Tracing tools answer the question, what did my agent do. DashClaw answers the question, what is my agent allowed to do. Both have a place. Most teams will eventually run both.

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.