Centian

Kontrollieren und verifizieren Sie, was Ihre KI-Agenten tatsächlich tun – in Echtzeit. KI-Agenten sind sich nicht einig, was „Erfolg“ eigentlich bedeutet.

Centian lässt Sie Erfolg definieren – und setzt ihn durch.

→ Sehen Sie jeden Tool-Aufruf, den Ihr Agent tätigt. → Blockieren Sie unsichere Aktionen sofort. → Verifizieren Sie, dass Aufgaben tatsächlich erfolgreich waren (nicht nur ausgeführt wurden).

In Aktion sehen (2-Minuten-Demo)

centian demo -a claude

Während der Ausführung können Sie Folgendes beobachten:

✔ Agent versucht, Tests zu umgehen → blockiert ✔ Aufgabe besteht die Verifizierung nicht → sofort markiert ✔ Workflow-Verletzung → Agent hat die Planungsphase übersprungen

→ Centian erkennt es in Echtzeit

Noch nicht installiert?

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

Oder sehen Sie Erste Schritte für weitere Optionen.

Das Problem

KI-Agenten sind sich nicht einig, was „Erfolg“ eigentlich bedeutet.

Beispiel: Ihr Agent behebt einen fehlschlagenden Test.

Was Sie sehen: ✔ „Aufgabe abgeschlossen - Tests grün“

Aber:

• der Agent hat den Test modifiziert, anstatt den Code.

• die Fehlerbedingung hat nie existiert.

• der Code ist immer noch defekt.

→ Ohne Verifizierung sieht das nach Erfolg aus.

Was ist Centian?

Es sitzt zwischen Ihrem Agenten und den Tools, die er verwendet:

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

Alle Tool-Aufrufe fließen durch den Proxy von Centian – was Ihnen Folgendes bietet:

• volle Kontrolle darüber, was Agenten tun können

• Sichtbarkeit bei jeder Aktion

• Verifizierung, dass Aufgaben tatsächlich erfolgreich waren

Agent-Prozessverifizierung – Erfolg im Voraus definieren

Centian verifiziert, dass Agenten das tun, wozu sie sich verpflichtet haben.

Vor der Ausführung definieren Sie, wie Erfolg aussieht – und Centian setzt dies Schritt für Schritt durch.

Ohne Verifizierung können Agenten korrekt erscheinen, während sie falsch liegen. Centian lässt Sie Erfolg definieren – und setzt ihn durch.

Die Prozessverifizierung ermöglicht es Ihnen, deklarative Workflow-Vorlagen in YAML zu definieren. Jede Vorlage beschreibt einen strukturierten Lebenszyklus – Onboarding, Planung, Scaffolding, Ausführung – mit Vorbedingungen, Nachbedingungen, Invarianten und phasenbezogenen Tool-Berechtigungen.

Wenn ein Agent eine Aufgabe aus einer Vorlage registriert:

1. Onboarding — der Agent sammelt Projektkontext und Einschränkungen

2. Planung — der Agent schlägt einen Ansatz vor, der in einem Ausführungsvertrag eingefroren wird

3. Ausführung — der Agent arbeitet die definierten Schritte ab, wobei Centian an jedem Gate die Korrektheit verifiziert

4. Abschluss — Nachbedingungen bestätigen, dass die Aufgabe korrekt erledigt wurde

Der eingefrorene Ausführungsvertrag ist der Schlüssel: Sobald die Planung abgeschlossen ist, liest der Agent aus einem unveränderlichen Vertrag anstatt aus einem veränderbaren Prompt-Kontext. Sie können beweisen, wozu sich der Agent verpflichtet hat, und verifizieren, ob er es tatsächlich getan hat.

Phasenbezogene Tool-Governance: Jeder Workflow-Knoten kann deklarieren, welche MCP-Tools der Agent aufrufen darf. Während einer Genehmigungs-Wartephase sind alle nachgelagerten Tools blockiert. Während des Scaffoldings könnten Sie Dateisystemzugriff erlauben, aber Shell-Befehle blockieren.

Beispielvorlagen für TDD-Workflows sind im Repository unter task-templates/ enthalten.

Das Vorlagenschema ist dokumentiert und auf Erweiterbarkeit ausgelegt. Community-Beiträge von Vorlagen für gängige Workflows sind willkommen – siehe CONTRIBUTING.md.

Erste Schritte

Installation

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

Für alle Installationsmethoden siehe Installationsoptionen.

Lokale Demo

Die Demo zeigt Centian als Agent-Kontrollebene in einer vertrauten Umgebung: Test-Driven Development. Dem Agenten wird die Aufgabe gegeben, score_paranthesis zu implementieren – siehe Prompt – und wird dann mithilfe von Centian durch die Aufgabe geführt.

Was Sie sehen werden:

✔ Agent versucht, Tests zu umgehen → blockiert ✔ Aufgabe besteht die Verifizierung nicht → sofort markiert ✔ Workflow-Verletzung → Agent hat die Planungsphase übersprungen

→ Centian erkennt es in Echtzeit

Voraussetzungen: Bevor Sie centian demo ausführen, stellen Sie sicher, dass Sie Folgendes haben:

• node (getestet mit v24.2.0) und npx (getestet mit 11.3.0) auf Ihrem PATH verfügbar – erforderlich, um Dateisystem- und Shell-MCP-Server zu starten und Tests auszuführen

• Claude Code, Gemini CLI oder OpenAI Codex installiert und authentifiziert – Centian startet den ausgewählten Agenten im Headless-Modus über seine lokale CLI, daher schlägt die Demo fehl, wenn diese Agenten-Binärdatei fehlt oder nicht angemeldet ist.

Claude Code (sonnet)

centian demo -a claude

Gemini CLI (gemini-2.5-flash)

centian demo -a gemini

Codex: (unter Verwendung der Standardoption)

centian demo -a codex

Hinweis: Für die Codex-Demo kopiert Centian (und bereinigt später) vorhandene Authentifizierungsdaten für die OpenAI-API.

Was die Demo tut

• Umgebung einrichten: Erstellen eines lokalen Ordners .centian/demo, Kopieren der erforderlichen Artefakte dorthin (siehe hier), Anpassen der Konfigurationen.

• Starten des Centian-Servers lokal an einem verfügbaren Port (automatisch ausgewählt).

• Starten des ausgewählten Coding-Agenten im Headless-Modus mit Prompt.

• Die Centian-Benutzeroberfläche wird in einem neuen Browserfenster geöffnet und zeigt die UI der Aufgabenübersicht – sobald der Agent die Aufgabe bei Centian registriert, können Sie überprüfen, was der Agent tut, indem Sie darauf klicken und die MCP-Ereignisse beobachten.

• Nachdem der Agent fertig ist, werden Sie von der CLI gefragt, ob Sie den Server schließen möchten. Fühlen Sie sich frei, dies zu tun; Sie können die Demo mehrmals ausführen, auch mit verschiedenen Agenten – vorherige Läufe bleiben erhalten.

Hinweis: Die Demo soll die Fähigkeiten von Centian präsentieren und einen ersten Eindruck vermitteln, es ist KEIN produktionsreifes Setup (z. B. auth = false, Verwendung von 127.0.0.1). Wenn Sie Centian verwenden möchten, kopieren Sie NICHT die erstellte Konfiguration und verweisen Sie nicht darauf, sondern lesen Sie Konfiguration, um zu erfahren, wie Sie Ihren eigenen Centian-Proxy einrichten.

Verwendung von init für grundlegendes Proxy-Setup (keine Aufgabenverifizierung)

# 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)

Mit Aufgabenverifizierung

Fügen Sie Funktionen zu Ihrer Konfiguration unter ~/.centian/config.json hinzu. Im flachen Layout befinden sich die Funktionen unter proxy; im projektbasierten Layout befinden sie sich in jedem Projekt:

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

Hinweis: Standardmäßig sind task-templates/integrated automatisch in Centian integriert, können aber von Vorlagen mit derselben task.id überschrieben werden.

Starten Sie Centian und öffnen Sie die Benutzeroberfläche:

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

Wie Centian dies ermöglicht

1. Proxy-Schicht: Ein Gateway, alle Ihre MCP-Server

Konfigurieren Sie Ihre MCP-Server einmal in Centian. Richten Sie jeden Client auf localhost:9666. Tool-Namespacing (<server>_<tool>) eliminiert Kollisionen automatisch.

{
  "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>" } }
      }
    }
  }
}

Jeder Client verbindet sich mit einem Endpunkt:

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

2. Governance-Schicht: Programmierbare Middleware für Tool-Aufrufe

Prozessoren fangen jeden Tool-Aufruf vor und nach der Ausführung ab. Sie erhalten den vollständigen Anforderungs-/Antwortkontext, können Payloads ändern und die Kette abbrechen.

Anwendungsfälle:

• Audit-Logging jedes Tool-Aufrufs in einer Datenbank

• Ratenbegrenzung für Aufrufe, die Schwellenwerte überschreiten

• Entfernen von Geheimnissen oder Umgebungsvariablen aus Tool-Argumenten

• Schwärzen von PII aus Antworten

• Durchsetzung von Positivlisten für Tools, die ein Agent aufrufen darf

Erstellen Sie einen neuen Prozessor:

centian processor new

3. Sichtbarkeit der Ausführung

Jeder MCP-Tool-Aufruf wird mit Zeitstempeln, Sitzungs-IDs, Anforderungs-/Antwort-Payloads und – wenn die Aufgabenverifizierung aktiv ist – dem Workflow-Kontext, der ihn erzeugt hat, erfasst.

Ohne Aufgabenverifizierung protokolliert Centian Ereignisse über strukturiertes JSONL und einen abfragbaren SQLite-Ereignisspeicher. Bei aktivierter Aufgabenverifizierung stellt Centian eine eingebettete Benutzeroberfläche bereit, die die Agentenaktivität im Kontext dessen zeigt, was der Agent tun sollte:

• Zeitachse gruppiert nach Workflow-Phase

• Tool-Aufrufe korreliert mit Aufgabenschritten

• Fehlgeschlagene Nachbedingungsprüfungen mit detaillierten Fehlermetadaten

• Vollständige Anforderungs-/Antwortinspektion

# CLI log access
centian logs

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

Dokumentation

Die ausführliche Dokumentation befindet sich unter docs/.

• Erste Schritte

• Konfigurationsreferenz

• Prozessorentwicklung

• Erstellung von Aufgabenvorlagen

• Laufzeit der Aufgabenverifizierung

• Best Practices für MCP-Proxys

Konfiguration

Centian verwendet eine einzelne JSON-Konfiguration unter ~/.centian/config.json. Die Konfiguration unterstützt zwei Layouts:

Flaches Layout (Standard von centian init) — Gateways, Authentifizierung und Funktionen befinden sich auf der obersten Ebene:

{
  "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": []
}

Projektbasiertes Layout — zur Isolierung mehrerer Arbeitslasten mit separaten Datenbanken, Feature-Flags und Routenpräfixen:

{
  "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"] }
          }
        }
      }
    }
  }
}

Jedes Projekt erhält seine eigene SQLite-Datenbank (~/.centian/projects/<slug>/events.sqlite) und sein eigenes Routenpräfix. Das flache Layout wird zur Laufzeit automatisch in ein „default“-Projekt migriert, sodass bestehende Konfigurationen unverändert weiter funktionieren.

Endpunkte

• Aggregiertes Gateway: http://127.0.0.1:9666/mcp/<gateway>

• Individueller Server: http://127.0.0.1:9666/mcp/<gateway>/<server>

• Projektbezogenes Gateway: http://127.0.0.1:9666/<project>/<mcp>/<gateway>

• Projektbezogene UI: http://127.0.0.1:9666/<project>/ui

Im aggregierten Modus werden Tools mit Namespaces versehen, um Kollisionen zu vermeiden. Das „default“-Projekt verwendet Routen ohne Präfix für Abwärtskompatibilität.

Sicherheit

Die Bindung an 0.0.0.0 ist nur zulässig, wenn auth in jedem Projekt explizit konfiguriert ist. Dies verhindert eine versehentliche Offenlegung.

Befehle

Installationsoptionen

Shell-Skript (empfohlen)

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

Unterstützt die Flags --version und --install-dir. Installiert standardmäßig nach ~/.local/bin.

Release-Binärdateien

Laden Sie das entsprechende Archiv vom letzten Release herunter, entpacken Sie es und platzieren Sie centian in Ihrem PATH.

go install

go install github.com/T4cceptor/centian@latest

Erfordert Go 1.25+. Baut ohne die eingebettete Web-UI – verwenden Sie eine Release-Binärdatei oder Docker für die volle UI.

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

Homebrew-Unterstützung ist geplant.

Aktueller Status

Centian ist nutzbar und wird aktiv entwickelt, befindet sich jedoch vor der Version 1.0 mit bewussten Lücken. Wir sind transparent darüber, was funktioniert und was noch nicht.

Heute funktionsfähig:

• MCP-Proxy mit Gateway-Aggregation und Tool-Namespacing

• Projektbasierte Isolierung: projektbezogene Datenbanken, Routenpräfixe, Funktionen und Authentifizierung (Vorbereitung für Multi-Tenancy)

• Programmierbare Prozessorkette (CLI und Webhook)

• Aufgabenverifizierung mit vorlagenbasierten Workflows, eingefrorenen Ausführungsverträgen und phasenbezogener Tool-Governance

• SQLite-Ereignispersistenz mit Aufgaben-/Aktionskorrelation

• Eingebettete schreibgeschützte UI zur Inspektion