Skip to content
Agent Process

Agents never hold your keys

Agent Process sits between your AI agents and your business, and holds the keys so they don’t have to.

  • Isolated per organisation, in the database
  • Passwords never reach an agent
  • Only people approve
  • Every action on the record

Every request crosses one checkpoint.

Checked, carried out with keys the agent never sees, and recorded, whether allowed or refused.

Your AI agent

  • Read order #5521
  • Delete customer #88
  • Issue a $740 refund
  • Email the customer

Agent Process

Passwords stay here

“Read order #5521”

  • Key is valid
  • Granted to this process
  • Read-only access

Checking…

Your systems

  • Orders database
  • Customer API
  • Payments API
  • Email

The record

  • Waiting for the first request…
Illustrative requests and systems.

What could go wrong, and what stops it.

Each answered by a control that is built in, not a policy.
  • Another organisation sees your data.

    Your organisation is separate. Your processes, data and records are walled off from every other organisation, at the database itself.

    How
    • Every organisation's data is kept apart in the database itself, with row-level security that the application's own database role can't bypass.
    • Every query is also scoped to your organisation in code, as a second layer.
  • An agent leaks or misuses a password.

    Passwords never reach agents. Agents get the answer they need, never the password or key behind it.

    How
    • Database passwords and API keys are encrypted at rest and never sent to an agent or written to logs.
    • Agents get named capabilities for a step, not secrets. A key you publish for someone else runs your processes; it doesn't expose your systems.
  • An agent changes or deletes data it shouldn't.

    Access is narrow by default. Nothing is reachable until you choose it, and nothing changes data unless you enabled that action.

    How
    • Nothing in a source is usable until an admin selects it, and nothing is usable by a process until it's granted. Grants are pinned to a version of the source.
    • PostgreSQL and SQL Server users are checked for write access and refused if they have it. MongoDB and Cosmos DB access is limited to read operations. Results are limited in rows, size and time.
    • An API endpoint that changes data works only if an admin enabled it as a write.
    • API calls go only to origins you approved. Private, loopback and cloud-metadata addresses are blocked and redirects are refused, unless an admin explicitly allows private networks.
    • Sample values that look sensitive are redacted, and every read and write is recorded in the run.
  • An agent's token is lost or leaked.

    You control every agent's access. Each agent acts as the person who connected it, with the access chosen, and can be switched off at once.

    How
    • A token acts as the person who created it, with their current role, limited to the scope chosen: run, or full.
    • Only a hash is stored. The token is shown once, and its format is recognised by secret scanners.
    • Tokens never expire by default. You can choose 30, 90 or 365 days instead, unused tokens are flagged after 90 days, and any token can be revoked at any time.
    • A token can't create other tokens, and the activity record names the token used. An admin can switch off every token in the organisation at once.
    • Agent-only keys can be limited to specific processes and paused.
  • An agent approves its own work, or a forwarded email approves something.

    People make the decisions. Only people approve, every yes is tied to exactly what they saw, and an email link can't decide anything on its own.

    How
    • Keys for agent-only accounts and run tokens can't decide approvals.
    • Each decision is tied to a frozen snapshot of the evidence the approver saw.
    • Email approval links are stored only as a hash, rate-limited, and decide nothing when opened. A second tap changes nothing.
    • Links stop working at the approval's due date or after 7 days, and changing an approver's address retires their old links.
  • The AI gets a judgement wrong.

    AI judgement with guardrails. Jev judges against your criteria. When it's unsure, a person decides, and agents can't change its answers.

    How
    • Only processes that use an AI check send anything to Jev, and only the content that check needs.
    • An unclear result doesn't pass on its own: it goes to a person or back for rework.
    • If Jev is unavailable, a required check waits instead of being skipped.
    • Agents can't submit or overwrite Jev's results. Each one is kept with the run, with the question it answered.
  • A retry pays a refund twice, or a failure slips through unnoticed.

    Correct when things go wrong. A retried request counts once, stale work is refused, and an unclear outcome goes to a person.

    How
    • Retried commands are safe: the same request twice has the effect of one.
    • Work handed in on an expired or replaced claim is refused.
    • Evidence is checked again when a step is accepted, so an edited record fails.
    • An external write with an unknown outcome is recorded as unknown, never retried automatically, and left for a person to resolve.
    • A step can send at most 25 emails, and test runs never send email or touch your real systems.

What the app records

A refund run in progress, and the tokens agents work with.
A run's map: three steps completed, the refund approval waiting, the rest not started
Every run shows where it is: done, waiting, not started.
A run's activity: who completed each step, when, and the note they left
Each step keeps who did it, when, and their note.
An agent's token with its access, when it was last used, and a Revoke button
See when each token was last used, and revoke it at once.

Your data

Where it lives
During the pilot, the database and the service run in Microsoft Azure’s Central India region.
Microsoft Azure
Hosting, the database, secrets and sending email.
TypeSafe (Jev)
Only the content an AI check needs, and only when a process uses one.