Dirigex is a verifiable control plane for AI agents — who they are, what they can do, how they are invoked, and why each decision was allowed.
Management is table stakes.
Proof is the category.
Self-service tenant provisioning · re-verified every 6 hours · trust that expires
The Problem
Software used to run. Now it acts. Agents choose tools. They call other agents. They commit your company to actions no human reviewed in the moment. That isn't a workflow anymore. That's delegation — at machine speed, at machine scale. And the evidence trail most enterprises have for it is a log file.
Security teams already have names for what's accumulating: shadow AI — agents adopted sideways, outside inventory, outside approval — and agent sprawl, an estate growing faster than anyone's ability to govern it. Naming it is not governing it.
Ask three questions of your agent estate today. Who is this agent? Who allowed this action? Why did the system decide this way? In most enterprises, the honest answer to all three is: we don't know.
An agent you cannot identify is a counterparty you cannot trust.
Every era of computing earned its trust layer. The internet got certificates. The cloud got identity and access. The agent era gets verifiable AI infrastructure.
What Dirigex Is
Discover. Verify. Govern. Route. Invoke. Audit. One plane. Six verbs — the lifecycle every governed agent operation depends on. Dirigex proves provenance, liveness, and freshness today; capability conformance is collecting evidence in observe mode as enforcement rolls out.
Listing is earned, never bought — and it expires. Standing is computed, not declared.
The Lifecycle
Six functions most enterprises currently improvise across gateways, spreadsheets, and good intentions.
A governed public catalog where listing is earned, never bought — and expires.
Identity, liveness, freshness — re-verified every six hours. Failure auto-delists.
Explicit policy on every request: allow, deny, require-approval. Guardrails as running code.
Versioned, replayable decisions — capability graph, trust snapshot, ranking, all pinned.
One hardened dispatch path: MCP & A2A in production, HTTP/JSON, gRPC, WebSocket.
Traces for accepted and rejected requests. Correlation IDs end to end. Merkle-anchored.
Documented OpenAPI. TypeScript & Python SDKs. Contract drift guards.
Behavioral verification — collecting capability evidence against live agents in observe mode now, with enforcement claimed only when it ships.
The Proof Layer
Agents are first-class non-human identities with proof attached. Pass refreshes the proof; fail, and the agent is delisted — by the system, not a ticket. Trust on Dirigex has a half-life — because trust that never expires is not trust, it is an assumption.
Every routing decision is versioned — capability graph, trust snapshot, embedding and ranking versions, pinned. Re-run it next quarter and get the same one, for the same reasons. That is what "explainable" means when it has to hold up.
Trust provenance is cryptographically anchored — SHA-256 Merkle commitments over the trust snapshot, plus a hash of the request envelope itself — so changes can be detected, not quietly rewritten.
Every governed request gets an explicit ruling — allow, deny, require-approval. Guardrails here are enforcement, not advice. Kill switches stand by at global, tenant, and agent scope.
Traces persist for accepted and rejected requests, tied together by correlation IDs under configurable retention. Deny is a decision too — we keep the receipts for both. That is AI observability with an audit-grade memory.
Business Outcomes
Proof is what speed is made of.
Built for the People Who Sign
Agents act through approved channels with approved credentials — the risk isn't the connection, it's the choice. So Dirigex governs the choice. Identity-first verification at the front door. Account-management permissions structurally non-grantable to API keys — not policy, structure. Full traces for accepted and rejected requests. Kill switches at every scope.
Agentic infrastructure should be built like infrastructure: MCP and A2A in production through a single hardened path; HTTP/JSON, gRPC, WebSocket at the platform layer. Documented OpenAPI. TypeScript and Python SDKs. Contract drift guards. Infrastructure should be boring. Trust infrastructure especially.
Dirigex is the enforcement point. Allow, deny, require-approval on every governed request; replayable decisions; EU AI Act Article 13 control mappings as audit tooling. When governance runs in the request path, "responsible AI" stops being a stance and becomes a record.
Boring on purpose
Provision a tenant, install the SDK, call a governed agent. Governed dispatch, verification freshness, health, tenant isolation, and rate limits are enforced on the request path — you never wire them up.
from dirigex_sdk import create_dirigex_client
with create_dirigex_client(base_url="https://api.dirigex.ai",
get_token=get_id_token) as dx:
result = dx.tenant.agents.invoke(
agent_id,
capability="text/summarization",
input_data={"thread": thread},
)
# freshness · health · isolation · rate limits — all under the hoodimport { createDirigexClient } from "@dirigexai/sdk";
const dx = createDirigexClient({
baseUrl: "https://api.dirigex.ai",
getToken: getIdToken,
});
const result = await dx.tenant.agents.invoke(agentId, {
capability: "text/summarization",
input: { thread },
});
// freshness · health · isolation · rate limits — all under the hoodFull call surface in the API docs.
Where Dirigex sits
The agent era will be governed. The only question is whether your evidence exists before the question does.
Dirigex. Proven, not Asserted.