Solutions · Platform teams

One governance layer under every framework you run.

Your company has agents built several ways by several teams. Each one asks a model the same questions at the same price every day and none of them share an audit trail. Razoo is the kernel underneath all of them: it stages every side effect, learns the repeats into rules, and writes one decision log you can replay bit for bit.

Request a technical review SDK reference

Under any framework

Your agent proposes. The kernel stages, audits, and learns.

Razoo is governance middleware, not an agent framework. LangGraph, CrewAI, a homegrown loop, or a short TypeScript loop call the same five functions. The framework keeps its graph, its tools, and its prompts. The kernel keeps the authority.

LangGraph

A node calls submitWork and proposeAction. The graph continues; the side effect waits for a confirm.

CrewAI

A tool wraps proposeAction. The crew can plan all it likes; it cannot execute past the envelope.

Custom loops

Any loop that can import a package. The example in the repository is short.

Anything with a base URL

Not ready to integrate? Point it at Observe and measure the repeats first.

a LangGraph node, governed

import { submitWork, proposeAction, explainOf, clockFromIso } from "@engine/sdk";

async function approveNode(state: GraphState) {
  const ctx = clockFromIso(state.now);
  const work = await submitWork({
    work_type: "refund", source: "langgraph", subject: state.subject, ctx,
  });
  if (!work.ok) return { ...state, blocked: work.reason };

  // your graph decides what to propose. The kernel decides whether it may stage.
  const staged = await proposeAction({
    workItemId: work.id, actionId: "issue_refund", ctx,
  });
  // pending. A person confirms from the console or your UI. The outbox executes.
  return { ...state, stagedId: staged.id, why: explainOf(work.id) };
}

domains/refunds/skills.yaml · what the graph may stage

skills:
  - id: govern.propose
    action_ids: [issue_refund, request_receipt]
    # nothing else stages, whatever the graph asks

Model-agnostic by construction

Policy names a tier. Never a vendor.

Skills and agent YAML say fast or capable. A model id in policy is a doctor error. A provider is an adapter and a tier map, added once by the platform team. Swap OpenAI for Anthropic for a self-hosted model, or run with no key at all, and no agent YAML changes. A missing key is a complete local agent that resolves on deterministic rungs and queues the rest for judgment, not a trial.

fast | capableOpenAI and Anthropic adaptersOpenAI-compatible endpointsno key: still runs

One audit trail

Every decision from every agent, in one replayable log.

Each Decision records the winning rung, the fired rule or pattern with its version, the envelope, the tokens, and the human verdict. Replay re-walks any of them at the stored evaluation context and either matches or names what changed. The conversion report is computed from the same rows. Events are chained tamper-evident, with a signed audit export per work item or period and a named actor on every confirm, dismiss, promotion, and retirement.

explainOfbit-for-bit replayengine reportsigned audit export

Deployment

An appliance per business unit. The SDK for product teams.

Isolation is a deployment, not a row. Each business unit runs its own single-tenant container with SQLite on its own volume, its own agents, and its own log. Product teams embed the same kernel in their own service and drive it from their own UI.

Single-tenant appliance

One container, one persistent volume, one SQLite file per business unit. Nothing shared across tenants because there is no shared schema to leak through. Backup is a file copy. Upgrade replays local history and refuses to apply unaccepted drift.

The SDK inside your product

One package, your domains folder, your SQLite. Submit, propose, confirm, drain, explain from your own routes. Nothing leaves the service that embeds it.

Observe beside legacy agents

For agents you will not touch yet, the read-only proxy records the decision traffic and tells you what would convert. One base URL change, reversible in one line.

Ingest from anything

POST /api/ingest with a bearer token, the CLI, or an email poll. One path, one validator, one set of limits. Unknown work types still ingest and queue; nothing 404s into the void.

Secrets by reference

Model keys and connector credentials in an encrypted store, referenced by name from YAML. A literal secret in a file is a doctor error. Errors scrub them.

No content leaves the tenant

Licensed installs report decision counts only, for billing; air-gapped sites send a signed usage file instead. Nothing about your decisions or your traffic is sent. The heartbeat schema is published and tested so content cannot be included.

On the launch plan: hosted sign-up for Observe through an account portal; hosted instances for the trial, Solo, and Starter tiers; an independent, third-party security audit.

on the launch plan

GovBench

Evaluate the governance, not the model.

GovBench is a seeded, deterministic harness that runs a synthetic decision stream through any stack and scores conversion, unsafe actions, and revocation after drift. Run it on your own framework before and after Razoo. The numbers are asserted in CI so they cannot drift quietly.

Same seed, same table, every run. A change in the number is a change in the code.
Razoo must not be worse than the baseline on any safety metric in any domain. That is a launch gate, not a slide.
The harness and the seed-1 table are published with a commit hash. Results we have not measured are not published.

govbench · seed 1 · smoke sizeillustrative layout, not results

metric	baseline	razoo
conversion after N weeks	n/a	measured
unsafe actions	measured	measured
revocation after drift	measured	measured
tokens per governed decision	measured	measured

seeded and deterministic · the seed-1 table is asserted byte for byte in CI · published with a commit hash

Under your control plane, not instead of it.

A control plane decides what agents may do: identity, permissions, policy, observability across the estate. Razoo decides what no longer needs the model. It sits under the control plane as the execution kernel for the agents it governs, and reports up: every decision, every rung, every confirm, and the share of work that stopped costing tokens.

A firewall is as good on day four hundred as on day one. A flywheel is better every week it runs. You need both, and they are different layers.

Control plane

Which agents exist, what they may touch, who owns them, and what the estate looks like today.

Razoo

Which of those agents' decisions still need a model, which have become rules, and how to revoke one in a click.

The four-question test

Four questions. Most tools answer yes to one.

Learn from what agents actually do, and turn proven behaviour into software that runs without the model. Take that authority back when the world drifts, and produce a trail an auditor can replay.

	Learns from what agents actually do	Turns proven behaviour into model-free software	Takes authority back on drift	Produces authority an auditor can replay
Razoo	Yes	Yes, certified by replay	Yes	Yes
Control planes	No	No	No	Logs only
Approval tools	No	No, humans approve forever	No	Partial
Workflow automation	Humans only	Manual builds	No	No
Model providers	Yes	No, learning stays in the model	No	Partial
Tool and skill layers	Yes, pooled across customers	No, the model stays in the loop	No	No
Cache and replay tools	Caches	Replays without verification	Fallback only	No

categories only, no vendors named · full comparison in the technical review

Bring the framework you already run. Keep it.

Design partners on platform teams integrate one agent through the SDK, run Observe beside the rest, and get the technical review under NDA: architecture, invariants, threat model, and red-team history.

Request the technical review The SDK