Request a demo (opens in a new tab)
Back to the stack

03 · The agent plane

Olympus

AI agents that do real engineering work and can’t ship until a multi-model review council clears them. Olympus runs those governed teams inside Habitat, your team’s workflow, on the shared Canon context your engineers already trust.

The source is yours to keep. No per-seat metering.

Layer
Agents, the top of the stack
Acts in
The Habitat workflow
Reads
Canon context, not a private copy
Status
Ships with the engagement

The problem it removes

An agent you can’t govern is an agent you can’t ship.

Drop a coding agent into a repo and it works from whatever context it was handed, keeps its own memory, and merges on its own judgment. It might be fast. It is not accountable, it does not compound with the rest of the team, and on anything that reaches production that is the whole problem. An AI-first team does not need more agents. It needs agents it can put to work and still trust.

See it work

One governed run, from pickup to merge.

An example run

The agent reads the decision Canon already holds, opens the change, and the council clears it across three models before it merges, with the whole run written to the commit history.

Why it’s different

Governed, so you can trust it in production.

A raw coding agent runs with a private, drifting copy of the context and merges on its own say-so. An Olympus agent reads the same Canon the team does and acts on the same Habitat board. Its work starts grounded and stays legible to a person picking up where it left off.

Then it has to clear the council. A multi-model review checks every change before it merges, adversarially, so no single agent and no single model gets the last word. Bolt a raw agent onto a repo and none of that comes with it. The governance is the product, and it is why the agents compound instead of splintering.

See it on your own stack (opens in a new tab)

What it does

Act, review, and govern.

  1. 01

    Act

    Puts agents on real work

    Governed agent teams pick up tickets on the same Habitat board your engineers use, work to the PRD, and open a real change. Each run reads the Canon context it needs, so an agent starts from what is already settled, not a private copy that drifts.

  2. 02

    Review

    Nothing merges unchecked

    Before a change lands, a multi-model review council checks it: correctness against the PRD, security, and an adversarial pass that tries to break it. No single agent and no single model gets the last word. Configure the gate to block the merge or to flag and pass.

  3. 03

    Govern

    Keeps every action on the record

    The canon sets the bounds an agent works inside, and every action lands in the commit record, so a run reads back later like any other change: who did it, what it touched, what cleared it. Nothing ungoverned reaches production. The audit trail is the default, not an add-on.

A closer look

An agent, on the record.

The Olympus dossier for Delphi, a security-analyst agent: cards for role, lifecycle, runtime, model, effort, trigger, allowed tools, and spend, above a run history with success and failure badges and a cost on every run.
Delphi's dossier. The role it owns, the model it runs through OpenRouter, the three tools it is allowed, and a run history that keeps every outcome and cost, failures included.

Where it runs

Your code stays yours.

In your environment

Olympus runs on your own infrastructure. Your source and context never leave it. The agents come to your code, not your code to them.

Any model, no lock-in

Model-agnostic through OpenRouter: the review council can span providers, and you choose the models. No single vendor owns the stack.

On the record

Every action is bounded by canon and logged to source, so what an agent did, and what cleared it, reads back like any other commit.

Bring your security review to the demo. Running in your own environment answers a lot of it before the first question.

By design

What governed agents guarantee.

Enforced on every run, not promised: the canon draws the limits an agent works within, the commit trail records what it did, and the review that cleared it stays attached.

Put an agent on your own backlog.

Thirty minutes with the people who build it: a working walkthrough and straight answers.

It ships with the engagement, tuned to your stack. The source is yours to keep. No per-seat metering.