Out-of-process Signing

Updated

Asqav is the unaffiliated third-party notary for AI tool call receipts. The signer runs in a trust boundary the agent does not own and holds keys the agent never touches. An external auditor verifies its receipts offline against the public verify key. This page documents the out-of-process deployment topology: the signer is the Asqav-hosted notary signer, a service in Asqav's cloud and outside every agent that calls it.

The unaffiliated-third-party position has a regulatory shape:

The signer running outside the agent process is what gives the resulting receipts verifiable evidentiary weight against these provisions. Asqav does not make legal admissibility claims; whether a receipt meets a given evidentiary standard is for the customer and its legal counsel to determine.

The threat the boundary closes

Threat model

An attacker who compromises the agent process, through prompt injection that achieves code execution, a poisoned tool dependency, or a memory-safety bug in a model runtime, gains arbitrary code execution inside the agent. With in-process signing, that attacker can:

With out-of-process signing, the attacker has process-level access to the agent but no read access to the signer's keys. The signer accepts request payloads, validates them and returns signed envelopes. The signer never returns the private key. A compromised agent can request signatures on attacker-chosen payloads, but it cannot retroactively rewrite the chain. The signer's local audit log captures every request the agent made.

Why this matters for compliance

Regulators and assessors expect the key custody question to have a clean answer, and that expectation comes from how the reviews run rather than from any clause naming a hardware security module. Take four of them:

Every one of those reviewers lands on the same question: where does the signing key live, and who can read it. Keys held in a hardware security module or a separate trust boundary keep that answer short, and the out-of-process signer is the architecture behind that answer.

What a compromised agent can still do

A precise threat model names the residual, not only the win. With Asqav, the agent process holds an API key and nothing else. The signing key and the receipt ledger live outside the agent, and they also live outside the agent operator's infrastructure.

What an attacker holding that API key cannot do:

What that attacker can still do:

The deployment topology

The agent process imports the Asqav SDK and calls the signer over HTTPS with its API key. The signer holds the ML-DSA-65 keys and checks each request before it signs and appends to the hash chain.

The signer keeps the key in Asqav's local encrypted key store, or on Enterprise in an Asqav-managed AWS KMS or GCP KMS (see Key Management).

Asqav operates the signer and its keys. The customer operates the agent and checks each receipt offline against the public verify key.

Calling the signer from the SDK

The Python SDK reaches the signer at https://api.asqav.com/api/v1. The agent holds no signing key, so the trust boundary sits between the agent and Asqav.

Asqav-hosted notary signer

python
import asqav

asqav.init()

agent = asqav.Agent.create("invoice-bot")
receipt = agent.sign(
    "filesystem:write",
    {"path": "/exports/q1-invoices.csv", "bytes": 18324},
)

Further reading

References