Skip to content
The platform

A control plane for your digital workforce

AgentOps is the governed runtime between your agents and your tools. Agents reason and propose; people approve what matters; and every action is recorded. Here is how the whole loop fits together.

  1. 01

    Connect

    Connect your tools with scoped credentials held in an encrypted vault. Read access runs inline; anything that changes the outside world is gated.

  2. 02

    Configure

    Pick an agent from the library, assign the tools it may use, and publish a version. Published versions are immutable, so every run is reproducible.

  3. 03

    Run

    Agents execute on a queue — never inline in a request. They reason over your context, call read tools freely, and prepare the actions that change things.

  4. 04

    Approve

    Every side-effecting action pauses in the Approval Centre for a human decision. No autonomous side effects — approval is the default, not an add-on.

  5. 05

    Audit

    Every event is projected to an append-only audit log, and Insights turn the run history into cost, reliability and time-saved you can show the board.

The approval gate

Agents propose. People decide.

Read-only tools — listing tasks, reading a thread, pulling a balance — run inline. But the moment an agent wants to change the outside world, that action stops and waits in the Approval Centre.

  • Human approval is the default, not a feature you remember to switch on.
  • Agents never approve their own work — that permission is reserved for people.
  • Every decision — approved or rejected, and why — is written to the audit log.
Runs inline Read
List tasksRead threadSearch filesGet balanceList issues
Waits for approval Gated
Send emailPost to SlackIssue refundCreate invoiceUpdate deal
Control & safety

Guardrails before the gate

Approval is the last line. Before an action ever reaches a human, you have already shaped what an agent can do, how much it can spend, and where its data may go.

Human approval by default

Side-effecting tool calls become actions that wait in the Approval Centre. Agents propose; people decide. Agents can never approve their own work.

Tool guardrails

Constrain what each tool may do — allow-lists, limits and conditions — so an agent stays inside the lines you set, before approval is ever reached.

Per-agent budgets

Cap spend and usage per agent and per workflow. When a budget is reached, work stops — no runaway costs, no surprises on the invoice.

Dry-run sandbox

Test an agent against real context without touching anything outside. See exactly what it would do before its first real run.

Provider & residency controls

Choose which AI model providers an agent may use, opt providers out of data retention, and control how long run history and audit data are kept. Governance over the model, not lock-in.

Immutable versions

A published agent version cannot be changed. Re-run it months later and the agent behaves identically — essential for audit and trust.

Visibility & operations

Run it like a real operation

A digital workforce only earns its place if you can see what it did, what it cost, and what it saved. AgentOps gives you the queue, the numbers and the record.

Approval Centre

One queue for every pending action, with the full context behind each one. Approve, reject with a reason, and keep the work flowing.

Value & performance insights

Run reliability, cost per outcome, tokens, approval-vs-rejection rate, time-to-approval and estimated time saved — measured, not guessed.

Run history & audit log

Every run and every decision is recorded in an append-only log. Nothing is ever quietly edited or deleted.

Notifications & digests

Get told when something needs you. Outbound notifications and approval digests keep the queue moving without anyone living in the dashboard.

Linear workflows

Chain agents and steps into a repeatable workflow for the work you run again and again — still gated, still audited end to end.

Public API & tokens

Drive AgentOps from your own systems with a scoped, expiring-token API — so agents fit into the stack you already run.

Built to be trusted

Solid foundations, not a prototype

AgentOps is multi-tenant from the ground up, with strict isolation between organisations. Agents run on queues — never synchronously inside a request — so heavy work never blocks your team, and a busy agent never takes the platform down with it.

Security & governance

  • Multi-tenant by design

    Strict isolation between organisations, enforced at every layer.

  • Queued execution

    Agents run on background queues, never inside a web request.

  • Immutable versions

    Published agent versions never change — runs are reproducible.

  • Append-only audit

    Domain events are projected to a log that is never edited or deleted.

See the loop on your own tools

See AgentOps on your own tools and workflows. Book a 30-minute demo and we will show you the governed loop end to end.

Book a demo Sign in to the app