Coriqo

Independent proof of what your AI did.

Coriqo creates independently verifiable evidence of AI decisions, agent actions and human accountability.

What we don’t do yet

The problem · when the bank asks for proof

AI actions are difficult to independently prove.

Monday morning. Your sponsor bank asks for proof of how your AI handled customer payments last quarter. Normally that means days of pulling logs, tickets, screenshots and approvals from several people. With Coriqo, you share one private link, a Trust Room, and their risk team checks the record themselves.

Here is what sits behind that link: one made-up night, every step of it working in the product today. Your payment controls decide whether money moves. Coriqo makes sure a named person knows within minutes, on a record the bank can check.

  1. 2:14 AM

    The agent steps outside its approved limits

    It tries to move money it was never allowed to move. Coriqo flags it against the limits Compliance approved in March and opens a finding.

  2. 2:16 AM

    The on-call risk officer is paged

    Moving money is the highest risk level the company has set, so a person is paged at once.

  3. 2:21 AM

    She acknowledges it

    The company’s paging tool is updated too. Her name and the minute go on the record.

  4. Next morning

    The finding has an owner

    And a due date, so it can’t drift into next quarter.

  5. Day 9

    Fixed, retested, closed

    The test that caught it runs again and passes. The owner closes the finding with a written reason.

  6. Months later

    The partner bank asks when a human knew

    Paged at 2:16, acknowledged at 2:21, closed on day 9. They check it themselves in the Trust Room.

The architecture · runtime + policy + Coriqo

Keep your cloud provider and existing GRC. Add the receipts.

Coriqo doesn’t replace the tools you already run. It gives them the one thing neither can produce on its own: an independent record of what your AI did and who approved it, checkable by an outsider who doesn’t trust your internal logs.

Your cloud provider

What ran

The runtime

Runs your models and agents, and logs internal system events inside your own cloud perimeter.

Your existing GRC

What should happen

The rulebook

Holds board policies, control owners and frameworks (SOC 2, ISO 42001, NIST), backed by self-uploaded exports.

Coriqo

What did happen

The receipts

Seals each agent’s approved limits, runtime actions and named human sign-offs outside your stack, so any reviewer can verify them on their own machine.

Where Coriqo fits

Your cloud and your GRC show what you set up. Coriqo shows what actually happened.

What you need to showYour cloud providerYour existing GRCCoriqo
Independent of the team being checkedNoLogs live inside your own cloud account under your admins.NoEvidence is uploaded by your own team.Yes see it (opens in a new tab)Checkpoint hashes published to Sigstore Rekor and time-stamped by DigiCert.
Blocks out-of-policy tool calls inline (enforce mode)NoLogs after execution.NoHolds static policies.Yes see it (opens in a new tab)coriqo-mcp checks each tools/call before the server sees it, adding 0.5–3.2 ms (measured on one laptop).
Proves no events were dropped (seq_gaps)NoAdmin-controlled retention.NoManual sample uploads.Yes see it (opens in a new tab)Sequence counters and device enrolment tracking, in the open-source runtime.
Keeps raw prompts and arguments out of logsNoTraces can contain PII.N/AYes see it (opens in a new tab)By default, only argument hashes (RFC 8785 SHA-256) and keyed message fingerprints.
Verifiable offline by an outsiderNoRequires console access.PartialStatic PDFs or portals.Yes see it (opens in a new tab)Trust Room link and verify_proof.py --offline.
Any edit after the fact immediately showsNoRetention and exports are admin-controlled.NoFiles and screenshots can be replaced.Yes see it (opens in a new tab)Ed25519 signature and Merkle check fails.

Columns compare categories of tool, not named vendors.

Keep both. Your cloud provider runs and logs your AI, and your GRC holds the policy. Coriqo adds the part neither gives you: an independent record someone outside can check.

Built to sit on top of your stack.

Keep your cloud provider. Keep its agent runtime and OpenTelemetry traces. Coriqo reads them without getting in the path of live traffic.

Keep your existing GRC. Import your AI register from ServiceNow, OneTrust or Excel, and push back signed evidence files you can file in Vanta, Drata or AuditBoard, for your reviewers to verify offline.

Not a fit if you only need SOC 2 paperwork and run no AI agents. A GRC tool alone will do.

Request an AI evidence reviewTake the product tour

The demo · one agent, start to finish

From approved limits to independent proof.

One sample agent, six steps. The product is shown on a demo tenant with sample data, and the steps follow the illustrative incident above.

Coriqo agent page for the Sanctions Review Agent on AWS Bedrock: in review, high risk, one open finding. The summary says it used the initiate_wire_transfer tool outside its approved limits and the finding is still in remediation. Below it, a readiness checklist and counts of open findings and flagged decisions.
The product on a demo tenant, with sample data. More product screens
  1. Approved permissionsThe Sanctions Review Agent runs on AWS Bedrock with approved limits: the tools it may use and what it may do.
  2. An action outside themIt uses initiate_wire_transfer, a tool outside those limits.
  3. A finding is generatedCoriqo flags the action against the limits and opens a high-risk finding.
  4. A human acknowledges itA named on-call officer is paged and acknowledges it. Their name and the minute go on the record.
  5. The evidence is sealedEach step is chained and signed, and a hash of the signed checkpoint is published outside Coriqo.
  6. Independent verificationThe bank runs verify_proof.py --offline on its own machine: Merkle proof, signature and no edits since sealed.

Run a sample agent caseTake the product tour

The product · three outcomes

Produce the evidence. Prove it. Share it.

  1. Produce evidenceRecord AI actions, permissions, decisions and human accountability as they happen, without changing how your AI runs.
  2. Verify independentlySeal the records so outside reviewers can check them on their own machine, without trusting Coriqo.
  3. Share with stakeholdersGive partner banks, customers, auditors and examiners the evidence they need, without access to your internal systems.

Underneath: four steps, from pull request to proof.

  1. Gate (CI/CD)coriqo-agents mandate check blocks the deploy in CI when an agent’s mandate doesn’t match the one Coriqo holds, before the code ships.
  2. Enforce (shadow or enforce)coriqo-mcp checks every tools/call against coriqo.mandate.yaml in memory, adding 0.5–3.2 ms (measured on one laptop). In enforce mode it refuses a violation before it reaches the upstream server; shadow records it.
  3. Seal (Zero-Text)Each decision, tool argument hash (RFC 8785 SHA-256) and sequence number joins a hash-chained record. Coriqo signs each checkpoint of that chain (Ed25519) and, by default, posts a hash of the signed checkpoint, never the content, to Sigstore Rekor and gets a DigiCert time-stamp.
  4. Verify (Offline)Your partner bank, customer or examiner checks the chain on their own machine (verify_proof.py --offline) with no Coriqo login required.

What each part proves, and what it doesn’t.

  • The signature shows who signed this checkpoint and that the record has not changed since. If you hold the signing key in your own KMS, that signer is you.
  • Rekor is a public log Coriqo doesn’t control. It shows the checkpoint hash was published and has not been rewritten.
  • DigiCert certifies the time. Its RFC 3161 time-stamp shows the checkpoint hash existed by that moment.
  • None of them proves the AI action itself was authentic. They prove properties of the submitted record, not of what happened upstream. Records taken from your logs are labelled imported, not device-attested.

The coriqo-mcp checker and Shield ship in the open-source byoai-runtime package, currently in pre-release (pip install --pre). The CI check ships in the coriqo-agents SDK, which isn’t on PyPI yet.

PUBLIC · OUTSIDE CORIQO Sigstore Rekor · DigiCert time-stamp The record append-only 1Captured 2Approved 3Chained 4Sealed 5Anchored API + MCP · TWO-WAY Traces Cloud Code Tickets

Partner bank · Auditor · Vendor review · IPO diligence

$ verify_proof.py --offline
PASS Merkle inclusion proof
PASS Ed25519 signature
PASS No edits since sealed

Run on their computer. No Coriqo account needed.

coriqo.mandate.yaml

spec: coriqo.mandate/v1
agent: { name: payments-assistant }
mode: enforce                  # shadow | enforce
on_stale_snapshot: fail_closed
tools:
  allowed: [search, get_balance, transfer_funds]
  prohibited: [delete_account]
on_violation: deny_and_halt_run

Watch one record go from your AI to a reviewer.

  1. Reading Coriqo copies what your AI does. Your AI keeps running.
  2. Sealing Each step is approved and sealed in order.
  3. Published A hash of the signed checkpoint goes to a public log outside Coriqo.
  4. Verified Your reviewer checks it on their own computer.
For CTOs & CISOs

Zero prompt text leaves your machine.

Built so your CISO doesn’t block the pilot. By default, Coriqo doesn’t record raw prompts, PII or tool arguments on disk or in our cloud.

  • Canonical argument hashing. coriqo-mcp seals an RFC 8785 canonical JSON SHA-256 fingerprint of tool arguments, proving which parameters ran without storing them. Hashes of short or guessable arguments can still be confirmed by someone who guesses them.
  • Local secret & PII blocking. byoai-shield strips emails, cards and SSNs into placeholders ([EMAIL_1]) and blocks leaked API keys (403) in the browser or proxy before text leaves the device.
  • Fail-closed controls. Set on_stale_snapshot: fail_closed so every call is refused once the cached mandate is older than max_staleness_s.
For CAEs & examiners

Not just unedited. Complete.

Tamper-evident logs mean nothing if an agent stops reporting. Cryptography proves records weren’t altered after they were written. Coriqo also proves nothing went missing in between.

  • Monotonic sequence gaps (seq_gaps). In the open-source runtime, every sealed entry carries a sequential counter per enrolled device. A dropped or skipped event triggers an immediate gap flag during verification.
  • Enrolment-based coverage. Fleet reconciliation measures shipped batches against enrolled devices, flagging silent agents (never_seen) instead of masking blind spots as zeroes.
Where to start

Start with the request on your desk.

If a partner institution can’t see who approved your agent’s actions, it can slow or pause your program.

Partner review

Your partner institution asks what your AI did, and who approved it.

Send a Trust Room link: a private page where the institution validates the record itself. Try the check on a sample.

For fintechs
Vendor review

A customer wants proof your agents stayed inside their limits.

Share each agent’s limits, findings and retests in the same Trust Room. Their risk team checks it themselves. See ours, signed the same way.

For AI platforms
IPO diligence

The diligence team asks how AI is controlled.

Show the inventory, each agent’s approved limits, the open findings and how each one closed.

For fintechs
Exam request

Your examiner wants the record, not the policy.

Hand over a sealed examiner package. It needs two sign-offs before it is sealed. What the examiner gets.

For financial institutions
Mapped to
  • SOC 2
  • ISO 27001
  • ISO 42001
  • SR 26-2 (models)
  • NIST AI RMF
  • EU AI Act
See the controls

What Coriqo is. AI trust infrastructure: a record of what an AI system or agent did, who approved it, and that the record was not changed afterwards, in a form an examiner can check without trusting Coriqo.

Who it is for. AI-enabled fintechs, AI platform and agent vendors selling to regulated buyers, and mid-market financial institutions running AI in production.

What it does not do. Coriqo does not audit or certify anything, and it is not legal advice. It holds no SOC 2 report today; SOC 2 is in progress. An AI feature drafts; a named person decides. AI apps such as Claude or ChatGPT can read an organization’s records, as the person who connected them, but cannot change anything; this is off until an admin turns it on.

  • Runs beside your systems, never in their way
  • AI features can be turned off
  • Hosted, or in your own cloud
  • Checkable without us

Security team? Read the detailed answers · our filled-in security questionnaire · what we don’t have yet, SOC 2 included