Integrate · the Trust plane in your stack

Wire it in one call.

Trust plane · n.

the independent layer between an AI agent and the action it wants to take — answering whether the action is allowed, before it happens.

+uniti runs beside your agent in one of four shapes — SDK, middleware, gateway, or proxy. The verdict comes back in milliseconds; the policy lives where you can read it.

The integration, in its simplest form

One call. One verdict.

// before the agent executes — ask the Trust plane. const verdict = await uniti.verify(action) if (verdict === "allow") execute(action) else halt(action)

The same shape in Python, Go, Java, or as a framework middleware hook.

Where it sits

Beside the work.
Never on it.

+uniti runs out-of-band. Your agent's data never passes through the Trust plane — only the intent does. Latency is measured in milliseconds, and the data path stays exactly as it is.

Four ways to wire it in

Pick the shape that fits
your runtime.

SDK

One call inside the agent's own code. Verify each action before execute(). The most direct path — the agent knows it's being verified.

In-process

Middleware

Drop in as a hook for MCP, LangChain, CrewAI, or AutoGen. No agent code changes — the framework calls the Trust plane on every tool invocation.

Framework hook

API Gateway

Sit in front of the systems your agents call. Every request gets verified before it lands — works for legacy and closed-source agents alike.

Per-endpoint

Proxy

Network-level placement for opaque or third-party agents. Decisions returned on a side channel; the agent never sees the verification layer.

Transparent

What happens per call

Five steps. Out-of-band.
Under 200 ms.

01 · Intent

Agent prepares.

The agent assembles the action and signs it with its registered key.

02 · Receive

Trust plane taps it.

Out-of-band, beside the work. Data stays where it is; only the intent travels.

03 · Evaluate

Five questions.

Authority, scope, trigger, approval, audit — against the active policy.

04 · Decide

Allow or block.

A signed verdict comes back in milliseconds, with a reason if it failed.

05 · Seal

Sealed in record.

Hash-chained, tamper-evident, re-verifiable offline — by anyone, later.

Policy lifecycle

Author. Deploy. Observe.
Tune. Enforce.

Policy lives in version control. Changes ship like code — and start in observe-only by default, so nothing breaks the day you turn it on.

01 · Author

Policy as code.

Capabilities, limits, approvers — declared in a readable bundle. Diffable.

02 · Deploy

Roll forward.

Versioned, signed, dated. Ships through your CI. Rollback is one commit.

03 · Observe

Run silently.

Decisions are logged, not enforced. Watch where it would have blocked.

04 · Tune

Shape to fit.

Adjust limits, approvers, sources. False positives are visible in the record.

05 · Enforce

Flip the switch.

Same verdicts, now binding. Block at Q-n, before the action ever executes.

Human approval, when it matters

The Trust plane knows
when to stop and ask.

High-consequence actions trigger a single-use approval token — bound to one specific action, by one specific human, once.

Bound. Single-use. Logged.

The token can't be replayed, can't be split, can't be moved to a different action. It expires on use. The approver, the time, and the exact action all sit in the sealed record — defensible from day one.

Ready to wire it in?

Run the Trust plane on your agents.

Pick the shape that fits your runtime. We'll have you in observe-only inside a week — no agent code changes for middleware, gateway, or proxy paths.

Start the conversation →