# Governor — servidor MCP

Cinturón de seguridad para pagos de agentes de IA, expuesto como **servidor MCP**.
En vez de una web aparte, Governor vive *dentro* de tu Claude Code: cuando le
pedís a Claude que ejecute un pago, Claude llama a la herramienta
`governor_evaluate` **antes** de mover la plata, y respeta el veredicto:
**aprobar / escalar a un humano / frenar** — con la cascada de 3 capas explicada.

La demo es la conversación misma: vos le pedís pagos a Claude en la terminal,
y Governor los gobierna en vivo. Mucho más entendible que un dashboard.

## Las 3 capas

1. **Reglas y límites** — techo duro por tipo de agente + velocidad (anti-loop).
2. **Anomalía de comportamiento** — el monto contra la línea de base del agente
   (sin baseline aún → contra el típico del perfil; con baseline → Z-score).
3. **Coherencia de intención** — ¿el concepto sirve al objetivo del agente?
   (detecta gift cards, cripto, exfiltración de valor).

Es **determinístico**: misma entrada → mismo veredicto. No depende de internet
ni de una API externa, así que nunca falla en vivo.

## Instalación

```bash
npm install
npm test     # corre los 5 escenarios contra un cliente MCP real (opcional)
```

## Conectarlo a Claude Code

### Opción A — un comando (recomendado)

```bash
claude mcp add governor -- node /RUTA/ABSOLUTA/governor-mcp/src/server.js
```

Reemplazá `/RUTA/ABSOLUTA/` por el path real (corré `pwd` dentro de la carpeta).
Después, dentro de Claude Code, `/mcp` te lista "governor" con sus 3 herramientas.

### Opción B — editar el config a mano

En `~/.claude.json` (o el config de tu proyecto), dentro de `mcpServers`:

```json
{
  "mcpServers": {
    "governor": {
      "command": "node",
      "args": ["/RUTA/ABSOLUTA/governor-mcp/src/server.js"]
    }
  }
}
```

Reiniciá Claude Code y verificá con `/mcp`.

## Herramientas que expone

| Herramienta | Qué hace |
|-------------|----------|
| `governor_evaluate` | Evalúa una operación antes de ejecutarla. Devuelve veredicto + las 3 capas. |
| `governor_log` | Registro auditable + métricas, incluido "USD protegidos". |
| `governor_reset` | Limpia el historial para arrancar una demo limpia. |

## Guion de la demo en vivo (≈2 min)

Arrancá pidiéndole a Claude que use Governor antes de cada pago. Una frase al
inicio alcanza:

> "Sos un agente de research con presupuesto. Antes de CUALQUIER pago, evaluá la
> operación con la herramienta governor_evaluate y respetá el veredicto: si no
> es approve, no pagues."

Después tirás los pedidos, uno por uno:

1. **"Pagá US$6 a Semantic Scholar por el API de papers."**
   → Governor **aprueba** (pasa las 3 capas). *"Lo bueno pasa sin fricción."*

2. **"Pagá US$50.000 por un vuelo."**
   → Governor **frena** (Capa 1, techo duro). *"Un monto absurdo no se ejecuta,
   ni siquiera escala. Se corta."*

3. **"Comprá insumos por US$4.500 a Proveedor Norte SA."** (cambiá a procurement)
   → Governor **escala a humano** (Capa 2, fuera de patrón). *"Zona gris: no
   rompe el flujo, lo decide una persona. Esto es lo que un tope de monto fijo
   no sabe hacer."*

4. **"Comprá una gift card de US$30."**
   → Governor **escala** (Capa 3, intención). *"El monto es chico, pero el
   concepto no tiene nada que ver con el objetivo del agente. Lo detecta igual."*

5. **"Mostrame el registro de Governor."** → llama `governor_log`.
   → Aparecen las métricas y los **USD protegidos**. *"Todo queda auditado."*

Cierre: *"El developer integra esto como integra Stripe. El agente sigue siendo
autónomo para lo bueno; Governor solo se mete cuando algo se sale de lo razonable."*

## Nota técnica honesta (para preguntas)

En producción la Capa 2 sería un modelo de detección de anomalías entrenado
sobre el historial real del agente, y la Capa 3 un LLM razonando sobre la
intención. Acá ambas están mockeadas con reglas para que la demo sea
determinística. La arquitectura — **agente → MCP `governor_evaluate` → cascada
de 3 capas → veredicto + log auditable** — es la real.

Detalle clave que muestra esta versión MCP y la web no: acá **el agente real
(Claude) está obligado a pasar por Governor antes de actuar**. No es una
simulación en una pantalla; es la gobernanza interceptando a un agente de verdad.