platform

<div align="center">

# SidClaw

**Approve, deny, and audit AI agent tool calls.**

Works with MCP, LangChain, OpenAI Agents, Claude Agent SDK, and 15+ more.

[![GitHub stars](https://img.shields.io/github/stars/sidclawhq/platform?style=flat-square&color=F59E0B)](https://github.com/sidclawhq/platform/stargazers)
[![npm version](https://img.shields.io/npm/v/@sidclaw/sdk?style=flat-square&color=3B82F6)](https://www.npmjs.com/package/@sidclaw/sdk)
[![PyPI version](https://img.shields.io/pypi/v/sidclaw?style=flat-square&color=3B82F6&label=PyPI)](https://pypi.org/project/sidclaw/)
[![License: Apache-2.0](https://img.shields.io/badge/SDK-Apache%202.0-22C55E?style=flat-square)](LICENSE)
[![License: FSL](https://img.shields.io/badge/Platform-FSL%201.1-F59E0B?style=flat-square)](LICENSE-PLATFORM)
[![Tests](https://img.shields.io/badge/tests-1050%2B%20passing-22C55E?style=flat-square)](https://github.com/sidclawhq/platform/actions)
[![CI](https://img.shields.io/github/actions/workflow/status/sidclawhq/platform/ci.yml?style=flat-square&label=build)](https://github.com/sidclawhq/platform/actions)

<a href="https://sidclaw.com" target="_blank">Website</a> · <a href="https://docs.sidclaw.com" target="_blank">Documentation</a> · <a href="https://demo.sidclaw.com" target="_blank">Live Demo</a> · <a href="https://www.npmjs.com/package/@sidclaw/sdk" target="_blank">SDK on npm</a> · <a href="https://pypi.org/project/sidclaw/" target="_blank">SDK on PyPI</a>

</div>

---

Your agents call tools without oversight. SidClaw intercepts every tool call, checks it against your policies, and holds risky actions for human review before they execute.

### Try it locally (10 seconds, no signup)

```bash
npx sidclaw-demo
```

Opens a local governance dashboard at `http://localhost:3030` with four pre-loaded scenarios (Claude Code `rm -rf`, fintech trade, DevOps scale-to-zero, clinical lab order). No signup, no Docker, no API key — just the approval card UX running in your browser.

### See it in action

![Atlas Financial Demo](docs/assets/atlas_demo.gif)

*Agent wants to send an email → policy flags it → reviewer sees full context → approves or denies → trace recorded.*

## Works With Your Stack

<div align="center">

![Integrations](docs/assets/integrations-grid.png)

</div>

SidClaw integrates with **18+ frameworks and platforms** — including OpenClaw (329K+ users), LangChain, OpenAI, MCP, Claude Agent SDK, Google ADK, NemoClaw, Copilot Studio, GitHub Copilot, and more. Add governance in one line of code. <a href="https://docs.sidclaw.com/docs/integrations" target="_blank">See all integrations →</a>

## See It In Action

### Customer Support Agent (Financial Services)

![Atlas Financial Demo](docs/assets/atlas_demo.gif)

*An AI agent wants to send a customer email. Policy flags it for review. The reviewer sees full context — who, what, why — and approves with one click. Every step is traced.*

### Infrastructure Automation (DevOps)

![DevOps Demo](docs/assets/devops_demo.gif)

*An AI agent wants to scale production services. High-risk deployments require human approval. Read-only monitoring is allowed instantly.*

### Clinical Decision Support (Healthcare)

![Healthcare Demo](docs/assets/health_demo.gif)

*An AI assistant recommends lab orders. The physician reviews the clinical context and approves. Medication prescribing is blocked by policy — only physicians can prescribe.*

## How It Works

```
Agent wants to act → SidClaw evaluates → Policy decides → Human approves (if needed) → Action executes → Trace recorded
```

Four primitives govern every agent action:

```
┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ Identity │ →  │  Policy  │ →  │ Approval │ →  │  Trace   │
│          │    │          │    │          │    │          │
│ Every    │    │ Every    │    │ High-risk│    │ Every    │
│ agent    │    │ action   │    │ actions  │    │ decision │
│ has an   │    │ evaluated│    │ get human│    │ creates  │
│ owner &  │    │ against  │    │ review   │    │ tamper-  │
│ scoped   │    │ explicit │    │ with rich│    │ evident  │
│ perms    │    │ rules    │    │ context  │    │ audit    │
└──────────┘    └──────────┘    └──────────┘    └──────────┘
```

- **allow** → action executes immediately, trace recorded
- **approval_required** → human sees context card, approves/denies, trace recorded
- **deny** → blocked before execution, no data accessed, trace recorded

## Deploy your own SidClaw instance ($0)

Railway is the recommended one-click deploy — it spins up Postgres + API + Dashboard together. Vercel hosts only the Next.js dashboard; pair it with a hosted API.

[![Deploy on Railway](https://railway.app/button.svg)](https://railway.com/new/template?template=https://github.com/sidclawhq/platform)

<details>
<summary><strong>Vercel (dashboard only — point at an existing SidClaw API)</strong></summary>

```
https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fsidclawhq%2Fplatform&root-directory=apps%2Fdashboard&env=NEXT_PUBLIC_API_URL&envDescription=Your%20SidClaw%20API%20base%20URL%20(e.g.%20https%3A%2F%2Fapi.sidclaw.com)
```

Vercel can only host the dashboard (Next.js). The API is Fastify — deploy it to Railway, Fly, Render, or run via Docker. Set `NEXT_PUBLIC_API_URL` on the dashboard project to point at it.

</details>

Under 3 minutes to a working instance on Railway.

---

## Quick Start — Pick What Fits

### Option 1: Claude Code Hooks (zero code)

For Claude Code users. Every `Bash`, `Write`, `Agent`, `mcp__*` tool call is governed by SidClaw:

```bash
# In the SidClaw platform repo
npm run hooks:install

# Then set two env vars
export SIDCLAW_BASE_URL=https://api.sidclaw.com
export SIDCLAW_API_KEY=ai_your_key_here
```

Restart Claude Code. `rm -rf` pauses for approval, `git push --force` gets flagged, every tool call is traced with a hash-chained audit trail. See [hooks/README.md](hooks/README.md).

### Option 2: `create-sidclaw-app` (interactive scaffold)

```bash
npx create-sidclaw-app my-agent
cd my-agent
npm start
```

### Option 3: MCP Governance Proxy (zero code, wraps any MCP server)

Jump to the [MCP Governance Proxy section below](#mcp-governance-proxy).

### Option 4: SDK wrapper (one line per tool)

```typescript
// Before: the agent decides, nobody reviews
await sendEmail({ to: "customer@example.com", subject: "Follow-up", body: "..." });

// After: wrap with SidClaw — now policies apply
const sendEmail = withGovernance(client, {
  operation: 'send_email',
  data_classification: 'confidential',
}, sendEmailFn);

await sendEmail({ to: "customer@example.com", subject: "Follow-up", body: "..." });
// → allow (executes) | approval_required (human reviews) | deny (blocked)
```

<details>
<summary>Same thing in Python</summary>

```python
@with_governance(client, GovernanceConfig(
    operation="send_email",
    data_classification="confidential",
))
def send_email(to, subject, body):
    email_service.send(to=to, subject=subject, body=body)
```
</details>

<details>
<summary><strong>Full TypeScript example with imports</strong></summary>

```bash
npm install @sidclaw/sdk
```

```typescript
import { AgentIdentityClient, withGovernance } from '@sidclaw/sdk';

const client = new AgentIdentityClient({
  apiKey: process.env.SIDCLAW_API_KEY,
  apiUrl: 'https://api.sidclaw.com',
  agentId: process.env.SIDCLAW_AGENT_ID,
});

const sendEmail = withGovernance(client, {
  operation: 'send_email',
  target_integration: 'email_service',
  resource_scope: 'customer_emails',
  data_classification: 'confidential',
}, async (to, subject, body) => {
  await emailService.send({ to, subject, body });
});

await sendEmail('customer@example.com', 'Follow-up', 'Hello...');
// allow → executes | approval_required → waits for human | deny → throws
```

</details>

<details>
<summary><strong>Full Python example with imports</strong></summary>

```bash
pip install sidclaw
```

```python
import os
from sidclaw import SidClaw
from sidclaw.middleware.generic import with_governance, GovernanceConfig

client = SidClaw(
    api_key=os.environ["SIDCLAW_API_KEY"],
    agent_id=os.environ["SIDCLAW_AGENT_ID"],
)

@with_governance(client, GovernanceConfig(
    operation="send_email",
    target_integration="email_service",
    data_classification="confidential",
))
def send_email(to, subject, body):
    email_service.send(to=to, subject=subject, body=body)
```

</details>

## MCP Governance Proxy

Wrap any MCP server with policy evaluation and approval workflows. Works with Claude Desktop, Cursor, VS Code, GitHub Copilot — any MCP client. Listed on the <a href="https://registry.modelcontextprotocol.io" target="_blank">official MCP Registry</a>.

Add to your `.mcp.json`:

```json
{
  "mcpServers": {
    "postgres-governed": {
      "command": "npx",
      "args": ["-y", "@sidclaw/sdk", "sidclaw-mcp-proxy", "--transport", "stdio"],
      "env": {
        "SIDCLAW_API_KEY": "ai_your_key",
        "SIDCLAW_AGENT_ID": "your-agent-id",
        "SIDCLAW_UPSTREAM_CMD": "npx",
        "SIDCLAW_UPSTREAM_ARGS": "-y,@modelcontextprotocol/server-postgres,postgresql://localhost/mydb"
      }
    }
  }
}
```

- `SELECT * FROM customers` → **allowed** (~50ms overhead)
- `DELETE FROM customers WHERE id = 5` → **held for human approval**
- `DROP TABLE customers` → **denied by policy**

<a href="https://docs.sidclaw.com/docs/integrations/claude-code" target="_blank">Full MCP governance docs →</a>

## Why not just auth / sandboxing / logging?

| Approach | What it solves | What it doesn't solve |
|----------|---------------|----------------------|
| **Auth (Okta, OAuth)** | Who is this agent? | Should this specific action execute right now? |
| **Sandboxing (Docker, WASM)** | Blast radius if something goes wrong | Whether the action should happen at all |
| **Logging (Langfuse, LangSmith)** | What happened after the fact | Intercepting actions before they execute |
| **Policy engines (OPA)** | General-purpose policy evaluation | Approval work