Centian

Controla y verifica lo que hacen realmente tus agentes de IA, en tiempo real. Los agentes de IA no están alineados sobre lo que significa realmente el "éxito".

Centian te permite definir el éxito y lo hace cumplir.

→ Observa cada llamada a herramienta que realiza tu agente. → Bloquea acciones inseguras al instante. → Verifica que las tareas realmente se hayan completado (no solo ejecutado).

Véalo en acción (demostración de 2 minutos)

centian demo -a claude

Durante la ejecución, puede observar:

✔ El agente intenta omitir las pruebas → bloqueado ✔ La tarea falla en la verificación → marcado inmediatamente ✔ Violación del flujo de trabajo → el agente omitió la fase de planificación

→ Centian lo detecta en tiempo real

¿Aún no lo tienes instalado?

curl -fsSL https://raw.githubusercontent.com/T4cceptor/centian/main/scripts/install.sh | bash

O consulta Primeros pasos para más opciones.

El problema

Los agentes de IA no están alineados sobre lo que significa realmente el "éxito".

Ejemplo: Tu agente corrige una prueba fallida.

Lo que ves: ✔ “Tarea completada - Pruebas en verde”

Pero:

• el agente modificó la prueba en lugar del código.

• la condición de fallo nunca existió.

• el código sigue roto.

→ Sin verificación, esto parece un éxito.

¿Qué es Centian?

Se sitúa entre tu agente y las herramientas que utiliza:

Agent (Claude / Codex / Gemini) -- the brain
↓
Centian -- the control layer
↓
MCP Tools (filesystem, APIs, DB) -- the actions

Todas las llamadas a herramientas fluyen a través del proxy de Centian, brindándote:

• control total sobre lo que pueden hacer los agentes

• visibilidad de cada acción

• verificación de que las tareas realmente se completaron

Verificación del proceso del agente: define el éxito por adelantado

Centian verifica que los agentes hagan lo que se comprometieron a hacer.

Antes de la ejecución, defines cómo es el éxito, y Centian lo hace cumplir paso a paso.

Sin verificación, los agentes pueden parecer correctos mientras están equivocados. Centian te permite definir el éxito y lo hace cumplir.

La verificación de procesos te permite definir plantillas de flujo de trabajo declarativas en YAML. Cada plantilla describe un ciclo de vida estructurado (incorporación, planificación, andamiaje, ejecución) con precondiciones, postcondiciones, invariantes y permisos de herramientas por fase.

Cuando un agente registra una tarea a partir de una plantilla:

1. Incorporación — el agente recopila el contexto y las restricciones del proyecto

2. Planificación — el agente propone un enfoque, que se congela en un contrato de ejecución

3. Ejecución — el agente trabaja a través de los pasos definidos, con Centian verificando la corrección en cada puerta

4. Finalización — las postcondiciones confirman que la tarea se realizó correctamente

El contrato de ejecución congelado es clave: una vez que se completa la planificación, el agente lee desde un contrato inmutable en lugar de un contexto de prompt mutable. Puedes probar lo que el agente se comprometió a hacer y verificar si realmente lo hizo.

Gobernanza de herramientas por fase: cada nodo de flujo de trabajo puede declarar qué herramientas MCP tiene permitido llamar el agente. Durante una fase de espera de aprobación, todas las herramientas posteriores están bloqueadas. Durante el andamiaje, podrías permitir el acceso al sistema de archivos pero bloquear los comandos de shell.

Se incluyen plantillas de ejemplo para flujos de trabajo TDD en el repositorio bajo task-templates/.

El esquema de la plantilla está documentado y diseñado para la extensibilidad. Las contribuciones de la comunidad de plantillas para flujos de trabajo comunes son bienvenidas; consulta CONTRIBUTING.md.

Primeros pasos

Instalación

curl -fsSL https://raw.githubusercontent.com/T4cceptor/centian/main/scripts/install.sh | bash

Para todos los métodos de instalación, consulta Opciones de instalación.

Demostración local

La demostración muestra a Centian como el plano de control del agente dentro de un entorno familiar: desarrollo guiado por pruebas (TDD). Al agente se le asigna la tarea de implementar score_paranthesis - ver prompt - y luego es guiado a través de la tarea usando Centian.

Lo que verás:

✔ El agente intenta omitir las pruebas → bloqueado ✔ La tarea falla en la verificación → marcado inmediatamente ✔ Violación del flujo de trabajo → el agente omitió la fase de planificación

→ Centian lo detecta en tiempo real

Requisitos previos: Antes de ejecutar centian demo, asegúrate de tener:

• node (probado con v24.2.0) y npx (probado con 11.3.0) disponibles en tu PATH - necesarios para iniciar los servidores MCP de sistema de archivos y shell, y ejecutar pruebas

• Claude Code, Gemini CLI o OpenAI Codex instalados y autenticados - Centian inicia el agente seleccionado en modo headless a través de su CLI local, por lo que la demostración fallará si falta ese binario del agente o si no ha iniciado sesión.

Claude Code (sonnet)

centian demo -a claude

Gemini CLI (gemini-2.5-flash)

centian demo -a gemini

Codex: (usando la opción predeterminada)

centian demo -a codex

Nota: para la demostración de codex, Centian copiará (y luego limpiará) el material de autenticación existente para la API de OpenAI.

Qué hace la demostración

• Configurar el entorno: crear una carpeta local .centian/demo, copiando los artefactos necesarios allí (ver aquí), ajustando las configuraciones.

• Iniciar el servidor Centian localmente en un puerto disponible (seleccionado automáticamente).

• Iniciar el agente de codificación seleccionado en modo headless con prompt.

• La interfaz de usuario de Centian se abre en una nueva ventana del navegador mostrando la interfaz de usuario de la página de descripción general de la tarea; una vez que el agente registra la tarea en Centian, puedes verificar lo que está haciendo el agente haciendo clic en él y observando los eventos MCP.

• Después de que el agente termine, la CLI te preguntará si deseas cerrar el servidor. Siéntete libre de hacerlo, puedes ejecutar la demostración varias veces, también con diferentes agentes; las ejecuciones anteriores se conservarán.

Nota: la demostración tiene la intención de mostrar las capacidades de Centian y dar una primera impresión, NO es una configuración de grado de producción (p. ej., auth = false, usando 127.0.0.1). Si deseas usar Centian, NO copies, pegues ni hagas referencia a la configuración creada, consulta Configuración para saber cómo configurar tu propio proxy Centian.

Usar init para una configuración básica de proxy (sin verificación de tareas)

# 1. Install
curl -fsSL https://raw.githubusercontent.com/T4cceptor/centian/main/scripts/install.sh | bash

# 2. Initialize with a starter MCP server
centian init -q
# Optional: check created config at ~/.centian/config.json

# 3. Add your own MCP servers
centian server add --name "filesystem" --command "npx" --args "-y,@modelcontextprotocol/server-filesystem,/path/to/project"
centian server add --name "deepwiki" --url "https://mcp.deepwiki.com/mcp"

# 4. Start the proxy
centian start

# 5. Point your MCP client at Centian (use the config shown during init)

Con verificación de tareas

Agrega capacidades a tu configuración en ~/.centian/config.json. En el diseño plano, las capacidades van bajo proxy; en el diseño basado en proyectos, van en cada proyecto:

{
  "proxy": {
    "capabilities": {
      "taskVerification": {
        "enabled": true,
        "templatesPath": "/path/to/task-templates"
      },
      "eventStorage": {
        "enabled": true,
        "driver": "sqlite"
      },
      "ui": {
        "enabled": true
      }
    }
  }
}

Nota: de forma predeterminada, las plantillas de tareas integradas se integran automáticamente en Centian, pero pueden/serán sobrescritas por plantillas que usen el mismo task.id

Inicia Centian y abre la interfaz de usuario:

centian start
# UI available at http://localhost:9666/ui/tasks

Cómo lo habilita Centian

1. Capa de proxy: Una puerta de enlace, todos tus servidores MCP

Configura tus servidores MCP una vez en Centian. Apunta cada cliente a localhost:9666. El espacio de nombres de herramientas (<server>_<tool>) elimina las colisiones automáticamente.

{
  "gateways": {
    "default": {
      "mcpServers": {
        "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"] },
        "github": { "url": "https://api.github.com/mcp", "headers": { "Authorization": "Bearer <token>" } }
      }
    }
  }
}

Cada cliente se conecta a un punto final:

{
  "mcpServers": {
    "centian": {
      "url": "http://127.0.0.1:9666/mcp/default",
      "headers": { "X-Centian-Auth": "<your-api-key>" }
    }
  }
}

2. Capa de gobernanza: Middleware programable para llamadas a herramientas

Los procesadores interceptan cada llamada a herramienta antes y después de la ejecución. Reciben el contexto completo de solicitud/respuesta, pueden modificar cargas útiles y pueden abortar la cadena.

Casos de uso:

• Registro de auditoría de cada llamada a herramienta en una base de datos

• Limitación de velocidad de llamadas que exceden los umbrales

• Eliminación de secretos o variables de entorno de los argumentos de la herramienta

• Redacción de PII de las respuestas

• Aplicación de listas de permitidos para qué herramientas puede llamar un agente

Crea un nuevo procesador:

centian processor new

3. Visibilidad de la ejecución

Cada llamada a herramienta MCP se captura con marcas de tiempo, ID de sesión, cargas útiles de solicitud/respuesta y, cuando la verificación de tareas está activa, el contexto del flujo de trabajo que la produjo.

Sin verificación de tareas, Centian registra eventos a través de JSONL estructurado y un almacén de eventos SQLite consultable. Con la verificación de tareas habilitada, Centian sirve una interfaz de usuario integrada que muestra la actividad del agente en el contexto de lo que se suponía que debía hacer el agente:

• Línea de tiempo agrupada por fase de flujo de trabajo

• Llamadas a herramientas correlacionadas con los pasos de la tarea

• Verificaciones de postcondiciones fallidas con metadatos de error detallados

• Inspección completa de solicitud/respuesta

# CLI log access
centian logs

# Embedded UI (when task verification + UI are enabled)
# http://localhost:9666/ui/tasks

Documentación

La documentación profunda se encuentra en docs/.

• Primeros pasos

• Referencia de configuración

• Desarrollo de procesadores

• Creación de plantillas de tareas

• Runtime de verificación de tareas

• Mejores prácticas de proxy MCP

Configuración

Centian utiliza una única configuración JSON en ~/.centian/config.json. La configuración admite dos diseños:

Diseño plano (predeterminado desde centian init) — las puertas de enlace, la autenticación y las capacidades viven en el nivel superior:

{
  "name": "Centian Server",
  "version": "1.0.0",
  "auth": true,
  "authHeader": "X-Centian-Auth",
  "proxy": {
    "host": "127.0.0.1",
    "port": "9666",
    "timeout": 30,
    "logLevel": "info",
    "capabilities": {
      "taskVerification": { "enabled": false },
      "eventStorage": { "enabled": true, "driver": "sqlite" },
      "ui": { "enabled": false }
    }
  },
  "gateways": {
    "default": {
      "mcpServers": {
        "my-server": {
          "url": "https://example.com/mcp",
          "headers": { "Authorization": "Bearer <token>" },
          "enabled": true
        }
      }
    }
  },
  "processors": []
}

Diseño basado en proyectos — para aislar múltiples cargas de trabajo con bases de datos, indicadores de características y prefijos de ruta separados:

{
  "name": "Centian Server",
  "version": "1.0.0",
  "proxy": {
    "host": "127.0.0.1",
    "port": "9666",
    "timeout": 30
  },
  "projects": {
    "team-alpha": {
      "auth": true,
      "capabilities": {
        "taskVerification": { "enabled": true },
        "eventStorage": { "enabled": true },
        "ui": { "enabled": true }
      },
      "gateways": {
        "workbench": {
          "mcpServers": {
            "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/workspace"] }
          }
        }
      }
    }
  }
}

Cada proyecto obtiene su propia base de datos SQLite (~/.centian/projects/<slug>/events.sqlite) y su propio prefijo de ruta. El diseño plano se migra automáticamente a un proyecto "default" en tiempo de ejecución, por lo que las configuraciones existentes siguen funcionando sin cambios.

Puntos finales

• Puerta de enlace agregada: http://127.0.0.1:9666/mcp/<gateway>

• Servidor individual: http://127.0.0.1:9666/mcp/<gateway>/<server>

• Puerta de enlace con alcance de proyecto: http://127.0.0.1:9666/<project>/<mcp>/<gateway>

• Interfaz de usuario con alcance de proyecto: http://127.0.0.1:9666/<project>/ui

En modo agregado, las herramientas tienen espacios de nombres para evitar colisiones. El proyecto "default" utiliza rutas sin prefijo para compatibilidad con versiones anteriores.

Seguridad

La vinculación a 0.0.0.0 solo se permite si auth está configurado explícitamente en cada proyecto. Esto evita la exposición accidental.

Comandos

Opciones de instalación

Script de shell (recomendado)

curl -fsSL https://raw.githubusercontent.com/T4cceptor/centian/main/scripts/install.sh | bash

Admite indicadores --version y --install-dir. Se instala en ~/.local/bin de forma predeterminada.

Binarios de lanzamiento

Descarga el archivo apropiado desde el último lanzamiento, extráelo y coloca centian en tu PATH.

go install

go install github.com/T4cceptor/centian@latest

Requiere Go 1.25+. Se compila sin la interfaz web integrada; usa un binario de lanzamiento o Docker para la interfaz completa.

Docker

# Full image (Linux, macOS, Windows)
docker run --rm -p 9666:9666 t4ce/centian:latest

# Alpine image
docker run --rm -p 9666:9666 t4ce/centian:latest-alpine

Homebrew

El soporte para Homebrew está planeado.

Estado actual

Centian es utilizable y se desarrolla activamente, pero es anterior a la versión 1.0 con brechas deliberadas. Somos transparentes sobre lo que funciona y lo que aún no.

Funciona hoy:

• Proxy MCP con agregación de puertas de enlace y espacios de nombres de herramientas

• Aislamiento basado en proyectos: bases de datos por proyecto, prefijos de ruta, capacidades y autenticación (preparación para multi-tenencia)

• Cadena de procesadores programable (CLI y webhook)

• Verificación de tareas con flujos de trabajo basados en plantillas, contratos de ejecución congelados y gobernanza de herramientas por fase

• Persistencia de eventos SQLite con correlación de tarea/acción

• Interfaz de usuario de solo lectura integrada para la inspección de ejecución de tareas

• Registro de solicitudes JSONL estructurado

• Descubrimiento automático de configuraciones MCP existentes (centian init -p <path>)

• Autenticación de clave API con alcance por puerta de enlace y por proyecto

Limitaciones conocidas:

• El estado de ejecución de la tarea es solo en memoria (no restaurable después de reiniciar)

• La gobernanza es a nivel de herramienta, no semántica (sin distinción de lectura vs. escritura dentro de una herramienta)

• SQLite es el único backend de almacenamiento (Postgres planeado)

• El soporte de OAuth o servidores MCP descendentes es limitado, aún no se admiten todos los flujos