Enterprise Evaluation

This page answers the go/no-go question for a CTO, Head of AI, or RSO evaluating Command Center for a regulated or audit-sensitive deployment. Reading time: approximately 10 minutes.

1. What Command Center is

Command Center is autonomous agent orchestration with cryptographic accountability; a business-outcome and HITL governance layer above Langfuse.

It answers three questions that Langfuse does not pose:

Combien coûte chaque résultat (pas chaque token)? Per-attestation pricing decouples your cost model from model verbosity.
Qui a approuvé? Every consequential action passes a human-in-the-loop gate; the approver identity is Ed25519-signed and Brain-archived.
Est-ce prouvable? Each pipeline step emits a STARK proof anchored on Starknet; ~50 ms to verify, ~100 KB compressed. The chain of custody is mathematically verifiable, not just logged.

Command Center does not replace Langfuse; it sits above it. If you already use Langfuse for token-level observability, Command Center adds the outcome accountability layer your compliance team requires.

2. System architecture

The data flow below shows how a developer-facing CLI connects all the way to on-chain settlement. Each layer is independently auditable.


  preste CLI  (developer workstation)
      |
      |  @vauban-org/agent-sdk  (MIT, npm)
      |
  Command Center  (HTTP + MCP server, Hono)
      |
      +-------- Brain  (institutional memory, knowledge graph)
      |             query_knowledge / archive_knowledge
      |
      +-------- Citadel  (planning, sprint/task state)
      |             update_task_status / create_initiative
      |
      +-------- Starknet validator  (settlement + proof anchor)
                    STARK proof hash  ~50 ms verify
                    self-hosted Pathfinder  (rpc.vauban.tech)

  Legend:
    preste CLI  → sends task + BYOK credentials
    agent-sdk   → wraps agent runtime, skill registry, quality gates
    CC MCP      → 10 tools: execute_agent, run_pipeline, run_audit ...
    Brain       → cosine-deduped knowledge, query by semantic similarity
    Citadel     → sprint/initiative state, prerequisites, drift signals
    Starknet    → Ed25519-signed proof anchored on-chain, HMAC-SHA256 events

All cross-product events are HMAC-SHA256 signed via @vauban-org/agent-sdk/auth/sign-event per ADR-ECO-017. No event crosses a product boundary without a verified signature and a 5-minute timestamp window.

3. Three use cases

3a. Audit firm: cryptographic run certificates

Audit firms bill by the engagement, not by the token. What they need is evidence: who ran what, when, with which inputs, and what was approved.

Every Command Center pipeline step produces a STARK proof. The proof hash, attestation count, and approver identity are archived in Brain and optionally anchored on Starknet. A concrete output from a 500-attestation engagement looks like this:

attestation_id:  att_7f3a2c91e4b0
proof_hash:      0x1a2b3c4d...  (STARK, ~100 KB compressed)
anchored_block:  1 204 381  (Starknet mainnet)
approved_by:     0x04330c3b...  (Ed25519, POH-bound)
timestamp:       2026-05-26T14:32:01Z
agent:           BUILDER (Groq Llama 3.3 70B)
outcome_quality: 0.91

This record is verifiable in ~50 ms by any party with the SDK, without contacting Vauban infrastructure. The audit trail is yours; Vauban is not in the verification path.

3b. Fintech compliance: per-result cost accounting and EU AI Act readiness

Fintechs under MiCA, DORA, or the EU AI Act need two things that generic observability tools do not provide: cost per business outcome (not per inference call) and a documented human approval gate.

Per ADR-ECO-059, Command Center prices by attestation: €0.05 per attestation on the PAYG tier, €500/month flat for Pro (20,000 attestations/month). If a compliance workflow produces 200 attested decisions per month, the cost is €10 on PAYG; a token-counting tool at the same usage would bill against inference volume, which is uncorrelated with compliance decision count and harder to budget.

The HITL gate records the approver and the timestamp. For EU AI Act Art. 55(c) serious incident reporting (15-day SLA, applicable since 2025-08-02 per ADR-ECO-047), every HITL-approved action has a verifiable chain of custody from which the RSO can extract the incident timeline within minutes.

3c. Sovereign infrastructure: zero data leaves the perimeter

Public sector and critical infrastructure operators require that no payload data leaves their network boundary. Command Center supports a fully self-hosted topology:

Brain: self-hosted Postgres + vector search (no Vauban cloud required).
Command Center: Docker image, runs on-premise or in an air-gapped K8s cluster.
LLM: LiteLLM on-premise (Qwen3-8B or any OpenAI-compatible endpoint); Groq is the default but is entirely optional.
Starknet: self-hosted Pathfinder validator; https://rpc.vauban.tech is the Vauban reference endpoint but any Pathfinder instance works.
SDK: MIT-licensed (@vauban-org/agent-sdk, published on npm per ADR-ECO-014); no proprietary runtime lock-in.

In this configuration the only data that leaves the perimeter is the STARK proof hash anchored on-chain; the proof itself (~100 KB compressed) stays on-premise.

4. EU AI Act Art. 55(c) posture

Article 55(c) of the EU AI Act requires providers of general-purpose AI (GPAI) models to notify the AI Office of serious incidents within 15 days of becoming aware of them. This obligation has been applicable since 2025-08-02 per ADR-ECO-047.

Command Center's role is as a GPAI deployer assistant, not a GPAI provider, unless the customer fine-tunes a model inside the orchestration loop. In the standard deployment pattern, the LLM is provided by Groq or a customer-owned LiteLLM instance; Command Center adds the governance and accountability layer above it.

The RSO (Phase 0: founder; Phase 2+: dedicated AI Governance Officer per ADR-ECO-047) is the decision-maker for Art. 55(c) notifications. No automated notification is triggered; the RSO exercises human judgment on whether an incident meets the serious-incident threshold before notifying the EU AI Office portal. The Brain-archived HITL records and STARK proof chain give the RSO the evidence needed to make that determination quickly.

5. TCO model: per-attestation vs per-token

The core pricing difference is what the unit measures: attestations count verified business outcomes; tokens count inference syllables.

Scenario Command Center (ADR-ECO-059) Typical token-counting tool

1,000 att/mo (PAYG) €50/mo (1 000 x €0.05) Variable; depends on model verbosity, not outcome count

20,000 att/mo (Pro) €500/mo flat Scales linearly with token volume; no outcome cap

Design partner (Sandbox) €0, 100 att/mo Free tiers typically time-limited or seat-limited

Bank / sovereign (Enterprise) Custom SLA + volume Custom enterprise contracts typical

A worked example: a compliance team runs 1,000 attested decisions per month. On PAYG, cost is €50/month. A comparable observability-only tool billing per token at $0.50/1M tokens, with each decision averaging 4,000 tokens, would bill $2.00 per decision, or $2,000/month at the same throughput. The per-attestation model aligns cost with compliance value delivered, not with LLM chattiness.

Billing flows out to vauban-billing per ADR-ECO-060; Command Center does not own Stripe credentials or subscription state directly.

6. Vendor lock-in posture

Exit risk is zero on the protocol layer and low on the data layer.

SDK is MIT-licensed (ADR-ECO-014, accepted 2026-04-29). @vauban-org/agent-sdk is published on npm under MIT. Any party can fork, extend, or redistribute.
Brain data is portable. All knowledge entries are plain JSON in Postgres; no proprietary encoding. Self-hosted deployment means you own the data from day one.
Proof artifacts are portable. STARK proofs are standard Cairo proofs verifiable by any Starknet-compatible verifier. Ed25519 signatures use the IETF standard (RFC 8032).
MCP is an open protocol. The MCP server speaks the Model Context Protocol (open spec). Any MCP-compatible client can connect.
Exit plan: stop subscribing, keep the MIT SDK and your self-hosted Brain, continue verifying STARK proofs offline. No proprietary artifact becomes unreadable.

7. Command Center vs Claude Code / Hermes / OpenClaw

Pick the tool that matches your accountability requirement, not the one with the most features.

Tool Best for Audit trail HITL gate Multi-agent fleet Self-hosted

Command Center Regulated / audit / enterprise fleet STARK proof + Brain-archived Built-in, Ed25519-signed 5 agents, 10 pipelines Full (MIT SDK)

Claude Code Single-developer IDE workflow Session log only Manual interrupts No N/A (SaaS)

Hermes OSS agent runtime experiments None by default No Single agent Yes (OSS)

OpenClaw OSS agent runtime experiments None by default No Limited Yes (OSS)

If your requirement is "a developer writes code faster", use Claude Code. If your requirement is "an agent fleet makes decisions that must be auditable and approvable", use Command Center.

8. Pilot onboarding

The design partner program gives regulated teams a structured 4-6 week evaluation with full access to the Sandbox tier (€0, 100 attestations/month) and a direct line to the engineering team.

What is included in the pilot:

Sandbox account provisioned within 48 hours of signup.
One onboarding call (90 minutes) covering system diagram, HITL gate configuration, and Brain setup.
Access to the preste CLI and @vauban-org/agent-sdk for integration testing.
Weekly check-in for the 4-6 week evaluation window.
Dedicated Brain project space for your evaluation data (self-hosted option available on request).

Typical pilot timeline:

Week 1: install preste, connect to Command Center MCP, run first attested pipeline.
Week 2-3: integrate with your existing LLM workflow; configure HITL gates for your approval policy.
Week 4-5: run a representative workload; review attestation records with your compliance team.
Week 6: go/no-go decision with documented evidence package.

To start a pilot, contact the design partner team: admin@vauban.tech. Include your use case (audit, compliance, sovereign infra, or other) and your target deployment topology (cloud, on-premise, air-gapped).