Developers

Connect the AI you already build

Add governance, observability and operational control to your AI systems without rebuilding them. One integration, whatever framework you chose.

Start with an API key API reference

The whole integration

const d = await opsai.actions.evaluate({
  agent: 'refund-resolver',
  action: 'issue.refund',
  subject: 'ORD-40122',
});

if (d.outcome === 'authorized') {
  await razorpay.refunds.create(…, d.grant);
}

One call before you act, and you honour the answer. Nothing else about your AI system changes.

What the integration looks like

One call before the action. Nothing inside your control flow.

OpsAI does not wrap your framework, sit in your graph, or proxy your inference. It answers one question at the boundary where your AI system calls out to something that can change state, and it records the answer either way.

The sample estate runs 11 AI systems across 8 different frameworks and 11 connected systems. Nothing in OpsAI branches on which framework built what — the framework is recorded because it is worth knowing, not because behaviour varies by it.

That is the practical claim of this section. If you have already built the thing, you do not rebuild it. If you are about to, choose whatever you were going to choose.

Any framework, unchanged: Governance attaches where your AI system calls out, not inside it. There is no SDK for your framework because there does not need to be one.
Policies as code, owned elsewhere: A policy compiles to a rule evaluated with no model call in the path. The team carrying the risk writes it; you do not hard-code it.
Credentials you never handle: Your code receives a grant scoped to one authorized action. No endpoint returns a stored credential, at any scope.
A trace per attempt: Six stages, the rule version in force, and the checks that ran — for refusals as well as successes.
Evidence you can verify: Sealed, digest-chained records. Walk the chain yourself rather than taking a claim about integrity on trust.
Webhooks for what you cannot see: Holds, expiries and escalations arrive as signed events, so a decision nobody made is visible in your own systems.

This section

Orientation here. The manual in the documentation.

These pages cover the shape of an integration and the decisions behind it. When you want every endpoint, every field and every error, the documentation is the place that has them — and each page below says which docs page it hands off to.

Quickstart

From an empty account to a traced, policy-evaluated action: create an organization and an API key, connect an AI system, send an event, write a policy.

Connect

Register an agent, application, model or automation with OpsAI, describe what it can reach, and start sending the events that make it observable.

SDK

Typed client libraries for connecting AI systems, evaluating actions, reading traces and managing policies from your own code.

MCP

Put an MCP server behind OpsAI so every tool call is checked against identity, policy and risk before it reaches the tool, and recorded after.

Webhooks

Receive decisions, approvals, risk events and incidents as they happen, so your own systems can react to what OpsAI observed.

API

A resource-oriented HTTP API covering the AI systems you connect, the policies that govern them and the record of what they did.

Start here if you are evaluating

Developer quickstart goes from an empty account to a first evaluated action: organization, API key, SDK, one call, and how to confirm it worked.

It is the setup path. The documentation quickstart is the conceptual one — connect, register, write a policy, evaluate, read the trace.

Start here if you are integrating

API overview covers the resource model and the conventions — idempotency, pagination, versioning, how errors are shaped.

Then the API reference for the endpoints themselves, with the errors that actually happen.

What you get back

A decision, the rule that produced it, and a reference to the record.

Everything a review would ask for is in the response. Which AI system, acting on what, judged against which version of which rule, with a pointer to the sealed evidence.

Evaluate

curl -X POST https://api.opsai.dev/v1/actions/evaluate \
  -H "Authorization: Bearer $OPSAI_API_KEY" \
  -d '{
    "agent": "refund-resolver",
    "action": "issue.refund",
    "subject": "ORD-40122",
    "amount": { "currency": "INR", "value": 18400 }
  }'

Response

{
  "id": "ACT-7512",
  "decision": "authorized",
  "bound": "refund.ceiling",
  "evidence": "EV-7512",
  "latency_ms": 11
}

Decision latency

11ms

no model call in the path

Lines of your code

evaluate, then honour the answer

Framework changes

governance is at the boundary

IllustrativeThe canonical action from the OpsAI sample estate. How the trace is built.

Where to start

An API key and one call you already know the answer to.

Pick an action your AI system takes today, evaluate it, and read the trace. Nothing is deployed and nothing changes until you honour the response.

Start with an API key SDKs API reference