The AEGIS CLI and MCP: governance for infrastructure teams and AI agents

Comp authority has usually lived in policy documents and human judgement. AEGIS turns it into something an infrastructure team can query, script, and replay — and something an AI agent can call under the same rules as a person.

Most governance software is a black box: a web console, a login, a screen a person clicks through. That is fine for a manager approving a single comp. It is the wrong shape for the people who keep an integrated resort's systems running. Infrastructure teams automate everything they touch — deployments, backups, audits, access reviews — and anything that cannot be automated becomes the thing that breaks at 3am.

CompWarden's AEGIS platform — the comp authority engine — is built for that reality. It ships a command-line interface and speaks the Model Context Protocol, so comp governance behaves like the rest of the infrastructure: programmable, inspectable, and testable from the outside.

Governance as infrastructure

The question infrastructure teams ask of any control is not "does it have a nice screen?" It is "can I automate it, and can I prove what it did?" Comp authority should answer both. If authorising a comp is a decision the business must defend, then the ability to query that decision, replay it, and script around it matters as much as the decision engine itself.

AEGIS treats the authority engine as a service, not a portal. The decision engine resolves each request in milliseconds; the workflow engine handles escalations; a Kafka event backbone carries the record; and every decision is sealed to an immutable, hash-chained, immudb-anchored audit trail. All of that is reachable programmatically — which is what lets governance sit inside pipelines and audits rather than beside them.

The AEGIS CLI

The CLI puts the authority engine in the terminal. From the shell, an infrastructure or compliance engineer can:

• Query an authority decision — ask whether a given comp, for a given role and limit, would be authorised right now, and read back the reasoning.
• Inspect matrix versions — list the versions of the delegation-of-authority matrix and see exactly which one is live.
• Replay a historical decision — re-run a past request against the matrix version that governed it, and confirm the engine still returns the same answer.
• Manage agent registrations — register and inspect the AI agents that hold delegated limits, from the same place everything else is managed.

None of this is a new interface to learn so much as an old habit to reuse. A decision check becomes a step in a pipeline. A matrix diff becomes part of a change review. A replay becomes a line in an audit script. Governance stops being a separate ceremony and becomes a command like any other.

MCP-native for AI agents

The same principle extends to the newest kind of operator on the floor: the AI agent. AEGIS is MCP-native — it speaks the Model Context Protocol — so agents connect to the authority engine through a standard protocol rather than a one-off integration. Agents from any vendor connect the same way, and there is no side door: an agent cannot reach comp value except through the governed path.

Every AI-agent call is a governed transaction: logged, timestamped, and tied to a delegated limit. An agent is a governed principal, exactly like an employee — within its delegated limit a comp is auto-issued; beyond it, the request routes to a human under the same matrix, ledger, and proof. The agent inherits authority from the matrix; it never invents its own.

This is the difference between bolting an AI onto a comp system and governing one. When the record shows a comp was issued by an agent, it shows which limit permitted it, when, and against which matrix version — the same defensible trail a human decision leaves behind.

Why this matters

Put the two together and the shape becomes clear. A governed principal — human or agent — never bypasses the matrix. And because the matrix is versioned data, decisions replay deterministically: the same inputs, against the same version, return the same answer every time. That is what makes an audit reproducible instead of a reconstruction.

For an infrastructure team, the payoff is a programmable, inspectable control plane instead of a black box. Comp authority becomes something you can check in a script, diff in a review, replay in an audit, and connect an agent to through a standard protocol — with every path routed through the same engine, the same ledger, and the same proof.

Issuance systems and consoles were built for people clicking through screens. AEGIS was built so the people and agents automating everything else can automate governance too — without giving up a single line of the audit trail.

For the governance model underneath all of this, see AI-agent governance for casino comps and building a comp approval matrix.