Why PRAE The agent is autonomous. The execution isn’t.

The enterprise agent problem

Agents move fast. Enterprise execution has constraints.

Prompts and instruction files tell an agent what it should do. On their own they cannot guarantee that what it executes stays within policy — and afterwards, an enterprise has to answer for every action, not every intention.

1. What was the agent trying to do?

   The call it requested — tool and target — on every row, beside a hash of the prompt it was given. Recorded, not inferred.

   Shipping

2. What was it allowed to do?

   The pack and version in force; a signed pack names the key that signed it.

   Shipping

3. What did PRAE allow, steer, hold, or deny?

   The verdict on each call, with the rule that produced it. Steering is recorded where it is configured.

   Shipping

4. What actually executed?

   Whether an allowed or released call ran or failed, and whether a tool result was withheld.

   Shipping

5. Why was the decision made?

   The clause, its stated reason, and every rule that matched.

   Shipping

6. Can the organization prove it afterward?

   A hash-chained, signed ledger; any row exports as a receipt checked without our systems.

   Shipping

7. Can validated knowledge be reused by future agents?

   Not yet. Your packs persist and govern every next run; promoting what a run validated into future agents’ context is still to build.

   On the roadmap

PRAE sits at the execution boundary — between what the agent decides and what runs — where each of these can be answered at the moment of the call.

Who it’s for

One control plane, three people who answer for it.

The PRAE difference

Control the execution — not just the conversation.

Each of these has its place, and PRAE works beside them. What none of them holds is the decision itself: the agent’s context and the policy, applied to a call before it runs.

Prompt and instruction management

Tells the agent what to do. The model may or may not follow it.

Runtime monitoring

Sees processes, files and sockets — some of it prevents — without the agent’s context.

Post-execution detection

Finds the action after it has run.

Model-based guardrails

A probabilistic judgment on the conversation, not on the call.

Red-team validation

Tests scenarios before deployment, not each call.

How PRAE works

Model decides intent. PRAE decides what executes.

PRAE is in the path, before execution — not watching after the fact. A refused call never runs, and the decision is on the record either way.

Nothing to the right of the boundary happens unless the decision allows it. PRAE does not replace the model or choose its actions; it decides which of them run.

Compounding

Every validated run can make the next run better grounded.

Through context and policy — never the model. PRAE does not train models or change their weights. Three steps of the loop run today; closing it is on the roadmap.

Built for the agent ecosystem

Not limited to one model, IDE or vendor.

There is no model in the enforcement path, so the policy does not depend on whose model the agent runs. One pack applies wherever PRAE is mounted — and where it can be mounted today is labelled below.

Integration

Control without replacing the stack.

PRAE mounts at the seam your agents already have. What you can install today is on the left; what we are building is on the right, and labelled as such.

Architecture

One boundary, in the path. Everything around it stays yours.

PRAE does not replace the model, the agent framework, or the infrastructure they run on. It is mounted where a call becomes an action.

1. Yours

   Agent / harness

   Your model, your agent framework, your harness. It decides what to attempt.

   ↓
2. PRAE

   PRAE execution boundary

   Policy + context + steering, applied to each call before it becomes an action.

   ↓
3. Yours

   Tool / system execution

   Your tools, systems and data. Only what the boundary allowed reaches them.

   ↓
4. Yours

   Evidence / ledger

   Written by PRAE for every decision, chained and signed with a key you hold. Yours to keep and to export.

How PRAE composes with the security you already run →