this is awesome I'm so pumped about it, thanks for making this!

DashClaw sits between your agents and their actions. Every action goes through a policy check before it runs. The agent waits until the decision comes back.

What it does:

- Guard policies defined in YAML. Conditions, thresholds, actions (allow / block / require_approval). Versioned, testable in CI via simulation endpoint.

- Decision recording to Postgres before the action fires. Action, context, assumptions, policy applied, outcome. All org-scoped.

- Human-in-the-loop over SSE with Redis broker. 10-min replay window so approvals survive disconnects. Agent holds pending until decision or timeout.

- CLI approval channel. `dashclaw approve ` from a second terminal. No browser needed.

- Node and Python SDKs. Wraps existing calls. No framework lock-in.

How the guard check works in practice:

    const decision = await claw.guard({ action_type: 'deploy', risk_score: 90 });
    if (decision.decision === 'block') return;

Works with LangChain, CrewAI, OpenAI tools, Anthropic tools, Autogen, or custom agents.

- Quick Demo w/Docker: npx dashclaw-demo

- End to End Demo: cd examples/openai-governed-agent && npm install && node index.js

That runs a real agent, attempts a high-risk action, DashClaw intercepts it, and waits for your approval in the browser. Or you can run npm install -g @dashclaw/cli and approve it in the terminal via dashclaw approve

Stack: Next.js 15 (JS, no TS), Neon Postgres, Redis, NextAuth, Vercel. MIT licensed.

Honest limitations: guard policies handle threshold and allowlist rules well. Contextual policies that reason over full conversation history are not there yet. Thinking about that as a separate eval layer rather than baking it into the guard runtime. Features in the Labs category are still in development, currently building out integrations and starting with Discord/Slack.

GitHub: https://github.com/ucsandman/DashClaw Demo (fixture data, no login): https://dashclaw.io

Happy to go deep on any part of the architecture.

Comments URL: https://news.ycombinator.com/item?id=47413969

Points: 1

# Comments: 1

If you put guardrails inside the prompt, the model can ignore them.

If you put them inside the agent framework, they can be bypassed.

DashClaw tries to solve this by intercepting actions instead of prompts. The agent can reason however it wants, but execution goes through a policy layer.

Curious how others are approaching this.

I’ve been experimenting with autonomous agents for the past year, and I kept running into the same uncomfortable problem:

Agents were making decisions I couldn’t fully see or justify.

They could call tools, trigger actions, and make assumptions based on incomplete context. Once systems start touching real infrastructure, that becomes pretty scary.

So I built DashClaw.

DashClaw sits between an agent and the tools it wants to use. Instead of executing actions directly, agents call DashClaw first.

DashClaw can:

• evaluate the decision • apply policy rules • require approval • log reasoning and assumptions • record the final outcome

The idea is to create a *decision trail* for agent systems so you can answer:

Why did the agent think this was okay? What information did it rely on? Who approved the action?

The project includes:

• Node and Python SDKs • a decision ledger for agent actions • policy guardrails before execution • a mission control dashboard for fleet activity • a self-hosted architecture

It’s completely open source and designed to be lightweight enough to run locally with agent frameworks.

I'm still figuring out what the right abstraction layer is for this kind of infrastructure, so I’d love feedback from people building agents.

Repo: https://github.com/ucsandman/DashClaw

Comments URL: https://news.ycombinator.com/item?id=47363957

Points: 2

# Comments: 2

Comments URL: https://news.ycombinator.com/item?id=46993097

Points: 2

# Comments: 0