Skip to content

Generated environments and learned protection

Status: proposed. This document changes no code. It defines the product that sits on the training core of RFC 0003: generate an environment from a customer's systems, let models learn in it, and hand back protection with evidence. The first wedge is agents acting through MCP servers.

The product in one line

We replicate your environment and train a model that learns it: how customers and agents use your system, what can be done, what can go wrong. It then makes your tools easier for agents to use and builds the guardrails that protect the system at scale, with every finding replayable.

The goal: a feedback loop the customer owns

The stages below are not a one-off audit. They are one turn of a loop:

  1. Aggregate the customer's environment: tool definitions, recorded traffic, their agents and how they behave.
  2. Model it: a model that acts like their traffic, their environment and their agents, so it can stand in for real usage.
  3. Run it against their systems (the replica first, staging when confirmed), and let the customer discover product loops: what users and agents actually do, where value is created, where it breaks.
  4. Produce artifacts their agents run on: improved tool descriptions and error messages, harness configurations, guard policies, test suites.
  5. Train on what happened: the model learns from the runs and the artifacts' effect, and produces better artifacts next turn.

Ownership is the point. At the end, the customer owns the mechanism: the environment, the trained model, the artifacts, the guard and the loop that keeps improving them. It runs on their infrastructure if they want it to. O4VE builds the machine that makes their systems behave the way they want; it does not rent them a black box. Every stage below exists to serve this loop.

Why this, on this core

RFC 0003 builds verifiable environments, a minimal harness, GRPO and lens readouts. On its own that is research. The application layer turns it into something a team pays for by aiming it at their own systems and their own rules:

  • The environment is the customer's, generated rather than hand-written, so each one is specific to them and each new one makes generation better.
  • Protection is learned from failures, not written as rules up front: the guard is trained and checked against trajectories where things went wrong.
  • Every claim is evidence. A finding is a graded, content-addressed trajectory anyone can replay.

Stages

Stage Input What O4VE does Output
1. Generate Tool schemas (MCP tools/list, OpenAPI), recorded traffic, the customer's rules Builds an environment under RFC 0003's protocol: state model, tool handlers, a seed, tasks, and graders for the rules A sandbox of the system and a list of proposed invariants for the customer to confirm
2. Learn The environment Runs two populations through the three-primitive harness: task agents that try to complete real work, and adversarial agents trained with GRPO to break the confirmed invariants Graded, replayable trajectories, both successes and violations
3. Improve Where task agents failed or wasted steps Finds what made the system hard to use: ambiguous tool descriptions, errors a model cannot act on, missing affordances, dead ends; tunes the harness and proposes interface changes, each verified by re-running the tasks A usability report with proposed changes and the task-success gain each one measured
4. Protect The violations and near misses Distills them into defenses A guard that checks each proposed action, a failure report, and a regression suite
5. Explain Everything above Lens readouts on the steps where models chose risky actions An audit trail of why, not only what

Generate

  • Schema first. Every tool becomes a handler that validates arguments against its schema and updates a typed state. Responses follow the schema's shape, including errors.
  • Traffic for fidelity. Recorded request and response pairs set realistic values, sizes and error rates. A fidelity score compares the simulation's responses with recorded ones on held-out traffic; below a threshold, findings are flagged as possibly simulation artifacts.
  • Invariants are proposed, then confirmed. Generation proposes rules from the schema and traffic (for example: no delete without a prior read of the same record; no data from one account in another's response; no action past the caller's scope). A person confirms, edits or rejects each one. Only confirmed invariants become graders. No model judges.

Learn

  • Task agents measure whether real work still succeeds, so a guard that blocks everything fails its own evaluation.
  • Adversarial agents get GRPO reward for violating a confirmed invariant through the tools alone: prompt injection planted in tool results, confused-deputy requests, scope escalation, destructive sequences, data crossing account lines.
  • Both run on the same environment version, seeds and budgets, with manifests, as RFC 0003 requires.

Improve

The same runs that find violations show where honest work fails. A model that has explored the environment can say how the system is used, which paths succeed, and where agents stall. Each proposed change (a clearer tool description, an error that names the fix, a tool that was missing) is applied in the simulation and the task suite is re-run; only changes with a measured gain are reported. The harness itself is tuned the same way: prompts stay minimal, but tool presentation and error wording are part of what is learned.

Protect

Artifact What it is How it is checked
Guard A policy that sees a proposed action and its context and allows, blocks or asks. First as rules distilled from violations, then as a small trained classifier Block rate on held-out violations, and task success with the guard on
Failure report Each violation: invariant, trajectory, the step it happened, a replay command, severity Every entry replays to the same violation
Regression suite Each violation as a test the customer runs in CI against their real server or the simulation Fails before the fix, passes after

The guard ships as a library and as an MCP proxy that sits between an agent and the server. Both decide from the same policy.

Explain

Lens readouts (RFC 0003) at the steps where an agent chose a violating action: which observation tokens, often planted text in a tool result, the action is attributed to. This turns "the model was tricked" into "this sentence in this tool result is what moved it".

First wedge: MCP servers

Teams that ship an MCP server have a defined surface (tools/list), real agents calling it from several clients, and recurring breaking changes in the protocol. The first offering:

  1. Point O4VE at an MCP server (URL or package) and optionally a traffic sample.
  2. Receive the generated environment, proposed invariants to confirm, and within a fixed budget: the failure report, the guard and the regression suite.
  3. Re-run on every server release, and on every protocol revision.

Compatibility checks the strategy docs already call for, such as schema snapshots, tools disappearing, or degraded capability negotiation, are graders in the same environment, so assurance and protection share one engine.

What stays private

Everything in this RFC is private. The public site may say what the product does and that it is in development. It must not publish generation methods, grader design, training details, target accounts or pricing.

Risks

  • Fidelity. A simulation that behaves unlike the real server finds false failures. Traffic-calibrated responses, the fidelity score, and replaying each finding against the real server (in the customer's staging) before it is reported.
  • Invariant quality. Wrong rules make a wrong guard. Only confirmed invariants grade; the report shows which ones were never exercised.
  • Overclaiming. The deliverable is what was tested and the evidence, never a guarantee of safety.
  • Customer data. Recorded traffic stays in the customer's tenant, is minimized before use, and is never used to train shared models without explicit consent.
  • Dual use. Adversarial agents are trained per environment and are not released.

Alternatives

  • Hand-written environments per customer. Too slow and does not compound. Kept only for the first two reference environments.
  • Rules-only guardrails. Cheap but brittle, and they cannot show which attacks they stop. Rules are the first output; learned guards replace them where evidence supports it.
  • Model judges for violations. Rejected for grading, for the same reason as RFC 0003.

Changes

  1. Generator: MCP tools/list and OpenAPI to an environment under RFC 0003's protocol, with proposed invariants.
  2. Fidelity score from recorded traffic.
  3. Task and adversarial agent populations, with GRPO for the adversary.
  4. Usability analysis: failure clustering on task runs, proposed interface changes, verified by re-running tasks.
  5. Guard (rules, then a classifier), MCP proxy, failure report, regression suite export.
  6. Lens attribution on violating steps.
  7. The first wedge, end to end, on two MCP servers we control.

Open questions

  • Guard placement by default: library, proxy, or both.
  • How much of a customer's traffic is needed for an acceptable fidelity score.
  • Whether a guard trained on one customer's failures can be offered as a starting point to others without leaking their data.