AI agent security: Fail closed.

ConvOps security is a request path built to refuse first: no workspace context, no data; no verified person, no write; where a workflow has a gate, no explicit approval, no step. Every layer a request crosses checks before it lets anything through.

row-level security with force · server-stamped identity · gates that refuse

request pathexample
Claude CodeAdvance step: release notes approved
  1. Verified sign-inwho is calling
  2. Workspace isolationwhich workspace
  3. Role checkallowed for this role
  4. Engine gateis the step ready
  5. Audit recordkept, before and after
travelling
in short

Is ConvOps secure enough for AI agents in production?

It is built to fail closed: no workspace context, no data; no verified account, no write; where a workflow has a gate, no approval means no step.

ConvOps is the operations layer for AI agents. It holds your team's process as workflows with gates, a shared memory, scheduled and unattended runs, programs, a plan board, metrics and a full audit trail. It does not sell or host models.

key facts · october 2026

  • Tenant isolation uses Postgres row-level security with FORCE, so even the table owner is subject to the policy.
  • The human identity on every write is derived on the server from the verified credential. It is never a request parameter.
  • The MCP surface uses OAuth 2.1 with JWKS verification. API keys are bcrypt-hashed, shown once, and act as their user until revoked.
  • There are three roles (owner, admin, member), enforced with real 403 refusals at the route and service layer.

best for

  • Security reviewers who want specific controls and their limits in writing.

not for

  • Teams that need expiring or tool-scoped API keys today. Keys do not expire and carry no per-tool scopes; a key acts as its user, across all their workspaces or a list you set.
  • Buyers who need a certification report. See what we do not claim below.

updated

the review

The three questions every review asks.

Before a team lets AI touch real work, someone has to answer these. Plainly, and with evidence.

“Can another team see our data?”

One missing filter in one query, and a workspace leaks. Application checks alone are one bug away from it.

“Was that the AI or a person?”

If the log trusts whatever name the caller sends, the log proves nothing.

“What stops an agent going too far?”

A rule written in a prompt is a request. The model can skip it, and nobody sees it happen.

the request path

Five layers. Each one can say no.

Every request from an AI client crosses the same layers, in the same order. Pick one and watch where it stops.

send a request
request pathexample
Claude CodeAdvance step: release notes approved
  1. Verified sign-inwho is calling
  2. Workspace isolationwhich workspace
  3. Role checkallowed for this role
  4. Engine gateis the step ready
  5. Audit recordkept, before and after
travelling
data isolation

Every workspace is sealed.

A query reads only the workspace its context points to. The wall is in the database itself, so an app bug cannot open it.

member of Support · exampleShow the refund tasks
Support
  • Refund over 200
  • Reply to ticket
  • Close duplicate
Finance
Engineering
global catalogthe only shared rows
credentials

You own every key.

Pick the provider, decide how each key arrives, and see where it goes. Executors hold no keys: they link your provider connections.

Your model provider

Connect a provider from the models.dev catalog, a Claude subscription, or your own OpenAI-compatible endpoint. ConvOps sells no models.

catalog · Claude subscription · your endpoint

How a key arrives

A teammate posts it to a one-time link, a signed-in person pastes it in the app, or you point at Google Secret Manager or a Kubernetes Secret. For a pointer, ConvOps keeps only the address.

one-time link · signed-in paste · vault reference

Encrypted, masked

Stored values are encrypted. A run gets only the keys it needs, and logs, check results and transcripts show a masked label. No tool returns a value.

given to the run, never shown

Git keys

ConvOps generates an SSH key and shows only its public half, or you supply a key or token. Scope it to one repository or a whole account. A check proves read and write.

generated or yours · repository or account

run 8c1e · keysexample
what holds

Six claims. Each with its limit.

Every claim comes with how far it goes and how it works. Read the middle row first.

Workspace isolation

01
What holds
A query without workspace context returns nothing. Not an error path: the default.
How far it goes
Every workspace-scoped table. Global catalog rows are the only shared surface.
How it works
Postgres row-level security with FORCE, so even the table owner cannot bypass it. App scoping and middleware sit on top.

Who did it

02
What holds
The person on every audit row comes from their verified sign-in.
How far it goes
The agent name beside it is self-declared, and is shown as exactly that.
How it works
Stamped server-side. No field, header or tool parameter exists that could carry it.

Sign-in

03
What holds
People sign in through the browser. No credentials sit in the AI client config.
How far it goes
API keys exist for automation. They have no expiry and no per-tool scopes.
How it works
OAuth 2.1 with JWKS verification. Keys are bcrypt-hashed and shown once, at creation.

Roles

04
What holds
Owner, admin, member. A refusal is a real 403, not a hidden button.
How far it goes
Three roles. No custom roles and no per-item permissions.
How it works
Checked at the route and the service layer. Last-owner protection keeps every workspace owned.

Audit

05
What holds
Every change to a task or a workflow run is kept, field by field, before and after.
How far it goes
Tasks and workflow instances. Not every table. Read it in the web app or the API.
How it works
Field-level diffs, plus a per-step history with the decision context.

Gates

06
What holds
A step whose gate is not met does not move. The agent is told what is missing.
How far it goes
Gates, required metrics and required reports stop a step. Policies are guidance the agent reads at the step.
How it works
The engine checks the gate against real state on every advance, not the agent.
on the record

What we do not claim.

A security review should not find surprises. These are the limits, stated before you ask.

not claimed9 limits, on the record
  • 01

    Expiring or tool-scoped API keys

    Keys have neither. A key acts as its user, across all their workspaces or a list you set, until you revoke it.

  • 02

    Granular permissions

    Three roles: owner, admin, member. Nothing finer.

  • 03

    An audit trail of everything

    Before and after diffs cover tasks and workflow instances only.

  • 04

    A recorded approver on every gate

    There is no separate approver field. The audit keeps the verified account behind the advance that passed the gate.

  • 05

    Approvals only a person can give

    Not offered. The approval is passed on the advance by any caller with access, a run included, and the audit names the verified account.

  • 06

    Policies that block

    Policies are guidance delivered to the agent. Gates are what refuse.

  • 07

    A verified agent name

    The agent label is self-declared. Only the person is verified.

  • 08

    Compliance certifications

    This page lists none. Ask us what your review needs.

  • 09

    Self-hosting on every plan

    Self-hosting is an Enterprise option, from one Helm chart delivered with Enterprise. This page describes the hosted service.

the principles

Five ideas the model rests on.

Fail closed

Missing context, a missing identity or an unmet gate all end the same way: nothing happens.

the default state

The wall is in the database

Isolation lives in the database itself. A bug in the app still cannot read across.

row-level security

Identity is derived

Who you are comes from your sign-in, never from what a caller says.

server-stamped

Three plain roles

Owner, admin, member. Quick to review, real refusals.

real 403s

Changes are kept

Before and after, field by field, on tasks and workflow runs.

scoped, honestly

the mechanics

The exact policy and payloads.

For the engineer on the review. The real policy, the real audit fields, and the scope of each.

The policy, as applied

Every tenant-scoped table carries this RLS policy, applied with FORCE. Rows with no owner are the shared global catalog.

payload
USING (
  org_id = current_setting(
    'app.current_tenant_id', TRUE)
  OR org_id IS NULL
)
The policy, as applied. Global catalog rows are the only shared surface.

Two identities on one row

The agent label is self-declared. The user fields are stamped server-side from the verified credential.

payload
{
  "actor": "implementer",
  "actor_user_id": "usr_…",
  "actor_user_name": "David Marsa"
}
Server-derived, never accepted as input.

Authentication

The MCP surface uses OAuth 2.1 with JWKS verification. A static key path exists for automation. Keys are bcrypt-hashed, shown once, and act as the user across all their workspaces or a list you set.

Audit scope

Field-level before and after diffs on tasks and workflow instances. Per-step history with decision context. The audit endpoints are REST and web app only; there is no MCP tool for them.

security review

Reviews happen with a person.

security review

Bring the questionnaire.

Bring your questions. We go through each control on this page with you, including where it stops.

  • Your questionnaire
  • Your data-flow questions
  • The person who signs off
questions

What reviewers ask first.

How does ConvOps keep AI agent data secure?

ConvOps fails closed at each layer a request crosses. Workspace isolation is Postgres row-level security with FORCE, the person on every change comes from the verified sign-in, a step whose gate is not met does not move, and changes to tasks and workflow instances are kept before and after. Example: a support team's refund tasks stay out of reach of finance, even if a query in the app forgets its filter.

What happens if a request arrives without tenant context?

It reads nothing. ConvOps keys its row-level security policy on the request's tenant setting, and with FORCE applied even the table owner cannot step around it. Fail closed is the default state, not an error path, so a missing filter in application code still cannot read across workspaces.

Can I recover an API key I lost?

No, by design. ConvOps stores API keys bcrypt-hashed and shows each one exactly once, at creation. If one is lost, you revoke it and create another. Keys are meant for automation, so treat them like passwords and keep them in your own secret store.

Where does the human identity on an audit row come from?

From the verified credential, stamped by the ConvOps server. No request field, header or tool parameter carries it, so neither an agent nor a caller can spoof it. The agent name beside it is self-declared and shown as exactly that, which keeps the claim and the verified person apart.

Do you support SSO?

No. ConvOps does not offer SSO or SCIM today. People sign in with OAuth through the browser, so no credentials sit in the AI client config, and the MCP surface authenticates with OAuth 2.1 and JWKS verification, with a static key path for automation.

How granular are roles?

ConvOps has three roles: owner, admin and member. They are enforced with real 403 refusals at the route and service layer, and the last owner of a workspace cannot be removed. There are no custom roles or per-item permissions, which keeps a vendor review short.

Do API keys expire, or carry scopes?

ConvOps API keys do not expire and carry no per-tool scopes. A key acts as its user, across all of that user's workspaces or a list you set, until it is revoked. People sign in with OAuth; keys are for automation, and should be handled like passwords.

What does the audit log cover?

The ConvOps audit log keeps field-level before and after values for tasks and workflow instances, the places where agents act. It does not cover every table. The audit log is read in the web app and the REST API, not from inside the chat client.

Can my search reach another workspace?

Only the workspaces you are a member of. ConvOps recall searches across your own memberships in one query; each memory stays owned by its workspace, and every write lands in exactly one. Example: a finance analyst who is not in the legal workspace never sees its memories.