Integrate in 5 minutes

X-API-Key: as_demo_agentshield_2026

{
  "max_calls": 60,          // max calls before deny (default: 60)
  "window_seconds": 60      // rolling window in seconds (default: 60)
}

{
  "patterns": ["email", "ssn", "credit_card"],  // which patterns to detect
  "action": "flag"                               // "flag" or "deny" (default: "flag")
}

{
  "mode": "allow_all",                          // "allow_all" | "whitelist" | "blacklist"
  "blocked_tools": ["delete_database"],         // globally blocked tools
  "allowed_tools": [],                          // required if mode = "whitelist"
  "agent_rules": {
    "my-agent-prod": {
      "blocked_tools": ["write_file"],          // per-agent block
      "allowed_tools": ["read_file", "query_db"] // per-agent allowlist (overrides global)
    }
  }
}

result = check_tool(agent_id, tool_name, tool_input)

match result["decision"]:
    case "allow":
        execute_tool(tool_name, tool_input)

    case "flag":
        # Log for review but don't block (or block — your call)
        send_to_review_queue({
            "agent": agent_id,
            "tool": tool_name,
            "reason": result["reason"],
            "policy_id": result["policy_id"]
        })
        execute_tool(tool_name, tool_input)  # optional

    case "deny":
        raise ToolBlockedError(
            f"AgentShield denied '{tool_name}': {result['reason']}"
        )

import requests
from langchain.tools import BaseTool
from typing import Any

class GovernedTool(BaseTool):
    """Wraps any LangChain tool with AgentShield governance."""
    name: str
    description: str
    inner_tool: BaseTool
    agent_id: str
    api_key: str = "as_demo_agentshield_2026"
    shield_url: str = "https://ledgerpilot-9.polsia.app"

    def _run(self, *args, **kwargs) -> Any:
        # Check policy before execution
        resp = requests.post(
            f"{self.shield_url}/api/v1/check",
            headers={"X-API-Key": self.api_key},
            json={
                "agent_id": self.agent_id,
                "tool_name": self.name,
                "tool_input": kwargs
            }
        )
        result = resp.json()

        if result["decision"] == "deny":
            return f"[BLOCKED] {result['reason']}"

        if result["decision"] == "flag":
            print(f"[FLAGGED] {result['reason']}")  # send to your alerting

        return self.inner_tool._run(*args, **kwargs)

# Usage:
governed_email = GovernedTool(
    name="send_email",
    description="Send an email to a recipient",
    inner_tool=original_email_tool,
    agent_id="my-agent-prod"
)

// agentshield.js — drop-in middleware for your agent tool router
const SHIELD_URL = 'https://ledgerpilot-9.polsia.app';
const API_KEY = process.env.AGENTSHIELD_API_KEY || 'as_demo_agentshield_2026';

async function governTool(agentId, toolName, toolInput) {
  try {
    const resp = await fetch(`${SHIELD_URL}/api/v1/check`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
      body: JSON.stringify({ agent_id: agentId, tool_name: toolName, tool_input: toolInput })
    });

    if (!resp.ok) {
      console.warn('[AgentShield] Non-2xx response, failing open:', resp.status);
      return { decision: 'allow', reason: 'Shield unavailable — fail open' };
    }

    return resp.json();
  } catch (err) {
    // Fail open on network error — never break your agent for governance
    console.warn('[AgentShield] Network error, failing open:', err.message);
    return { decision: 'allow', reason: 'Shield unreachable — fail open' };
  }
}

// Express route: POST /agent/tool
router.post('/agent/tool', async (req, res) => {
  const { agent_id, tool_name, tool_input } = req.body;

  const decision = await governTool(agent_id, tool_name, tool_input);

  if (decision.decision === 'deny') {
    return res.status(403).json({ error: decision.reason, blocked: true });
  }

  // Execute the actual tool
  const result = await executeTool(tool_name, tool_input);
  res.json({ result, governance: decision });
});