Plain engineering answers on pre-action enforcement, maker-checker separation of duties, server-checked step-up MFA (acr / amr), per-action signed receipts (aa.receipt.v1), Unknown and Conflict outcomes, what we do not claim, and when not to buy.
Guardrails inspect model text and observability records what already happened; the gateway decides on the structured tool call before it reaches the target system.
Prompt guardrails inspect text going into or out of a model, and observability tools record traces after a tool call has run. Neither sits on the write path to the target system. ActEscrow places a gateway between the agent and the target (for example an ERP supplier record or invoice approval). The gateway validates the tool parameters against a strict schema (unknown parameters are rejected), the control plane computes a canonical digest of the action (RFC 8785 JSON canonicalization + SHA-256) and evaluates it against the tenant's active policy, and the action is allowed, denied, or held for human approval before any downstream call is made.
Only if it has its own credential or network route to the ERP. Enforcement holds where the agent has neither; that boundary is a deployment requirement.
Pre-action enforcement is only as strong as the credential and network boundary around it. The gateway holds the downstream connector credentials; agents authenticate to the gateway, not to the ERP. If an agent (or a person) also has a direct ERP credential or network route, they can change records outside the gateway, and the gateway cannot prevent that. Removing those direct routes is part of every deployment, and we state this boundary explicitly rather than claiming enforcement we cannot provide.
The system is fail-closed: errors, missing policies and an unreachable control plane never result in an automatic allow.
Every evaluation path is fail-closed. If no rule matches, if evaluation errors, or if the gateway cannot reach the control plane (it returns control_plane_unavailable), the action is not executed. Uncertainty is never resolved in favour of execution.
When a rule requires separation of duties, the person who requested the action, or who owns the requesting agent, cannot approve it.
Policy rules carry a separation-of-duties flag (on by default). When it is set, the control plane refuses an approval from the principal who requested the action and from the owner of the requesting agent, returning separation_of_duties. Blocked self-approval attempts are themselves recorded in the evidence chain (approval.rejected_attempt), because repeated attempts are a security signal.
A UI prompt can be skipped by calling the API directly; the control plane checks the token's acr/amr claims and refuses approvals without them.
A confirmation dialog in the browser does not protect the API. For approver and admin operations the control plane requires an accepted authentication-strength signal in the bearer token: an acr value from the configured set (defaults include aal2 and urn:keycloak:acr:2fa) or an accepted amr value. Without it, the API returns HTTP 403 with code mfa_required, a WWW-Authenticate header (insufficient_user_authentication) and the acr_values the client should request, so the portal can send the user through an identity-provider step-up flow.
Approvals are bound to the action's canonical SHA-256 digest; if the action changed, the approval is refused with digest_mismatch.
When an action is proposed, the control plane canonicalizes it (RFC 8785) and stores its SHA-256 action digest. The approver's decision carries the digest of what they reviewed. If it does not match the stored digest, the approval is rejected with HTTP 409 digest_mismatch ("The action differs from what you reviewed"). Execution then runs only the action bound to that digest.
It reads RFC 8693 token-exchange delegation (sub + act.sub) from the verified token and rejects conflicting on-behalf-of claims in the request body.
Agents should not act under a shared static key. With OAuth 2.0 Token Exchange (RFC 8693) the identity provider issues a token whose act claim names the acting party. When a verified act claim is present, the token's sub is treated as the authoritative delegator and any conflicting onBehalfOf value in the request body is rejected (delegation_mismatch); a malformed act claim is refused. Policies can also require delegation (delegation_required).
Evidence is a per-tenant SHA-256 hash chain that the application database role can only append to, with ECDSA P-256 signed checkpoints.
Ordinary log rows can be edited or deleted by anyone with sufficient database access, and nothing downstream notices. Here, each lifecycle event (for example action.evaluated, approval.recorded, execution.outcome) is canonicalized and chained per tenant so every event hash depends on the previous one. The runtime database role cannot UPDATE or DELETE evidence or approvals (append-only) and cannot bypass row-level security. Periodic checkpoints over the chain head are signed with ECDSA P-256 and can be written to an S3 Object Lock bucket in COMPLIANCE mode. Evidence can also be pushed to your SIEM; the SIEM is a copy, not the source of truth.
A small signed JSON document (aa.receipt.v1) for one action: its digest, policy, approvals, outcome, observation and evidence hashes. No PII.
GET /v1/actions/{id}/receipt returns a receipt (schema aa.receipt.v1) for a single action. It contains only identifiers, digests, timestamps and states: the action digest, the policy revision and matched rule, each approval (approver id, approved digest, time, acr), the execution id, the target reference, the observed result (observed, not_observed or contradicted), the final status (including Conflict), the evidence sequence range with event hashes, and an ECDSA P-256 signature with its key id (kid). It contains no business values such as bank details, so it can be attached to a ticket or audit file. It proves what the system recorded and signed; it does not prove the model's reasoning was correct.
With the standalone aa-verify CLI, offline, using the exported files and the published public keys.
aa-verify runs offline and never calls back to the control plane. To check a tenant export: aa-verify --tenant <id> --export <file|dir>, optionally with --checkpoints <dir> and --public-key <pem> to verify signed checkpoints (repeat --public-key for retired keys). To check a single receipt downloaded from an action's detail page (Download receipt (.json) saves receipt-<actionId>.json): aa-verify receipt <file> --public-key <pem> (the action page also provides a Copy command button for aa-verify receipt receipt-<actionId>.json --public-key anchoring-public-key.pem, where anchoring-public-key.pem comes from GET /v1/evidence/anchoring-key). Any altered byte makes verification fail with a non-zero exit code; --json produces a machine-readable report.
The action becomes Unknown. It is never blindly retried; the outcome must be reconciled against the target first.
If the request may have reached the target but no reliable answer came back, the outcome is genuinely unknown, and retrying a payment or bank-detail change could apply it twice. The action is recorded as Unknown and is not retried automatically. Adapters pass an idempotency key downstream and support lookup by it, and such executions appear in the reconciliation list (GET /v1/executions/reconciliation) until their real outcome is confirmed against the target system.
The target accepted the write, but re-reading the record shows a state that contradicts what was approved.
A success response from a target does not always mean the approved change is what persisted: the target may normalize or overwrite a field. After a write, the adapter re-reads the record and compares it with the approved intent. If they match, the outcome is Succeeded (receipt observation: observed). If the record contradicts the approval, the action ends in Conflict (observation: contradicted). Conflict is final, needs human review, and is never shown as completed.
Not automatically today. The gateway records only changes that go through it; finding out-of-band edits is handled by runbook.
The evidence chain covers actions that pass through the gateway. We do not currently run a background job that scans the ERP for changes made by other routes. The read-back after each execution catches a contradicting state on the record we just wrote, and the runbook for suspected duplicate or unauthorized changes describes how to investigate edits made elsewhere. Closing direct access routes (see the bypass question) remains the primary control.
PostgreSQL row-level security on tenant-scoped tables, keyed on a per-connection app.tenant_id, with a runtime role that cannot bypass it.
Isolation does not rely only on WHERE clauses in application code. Every database connection opened for a request sets app.tenant_id from the authenticated tenant, and tenant-scoped tables have PostgreSQL row-level security policies keyed on it. The runtime role cannot bypass RLS, and the tenant comes from the verified token, never from the request body.
Business values are kept out of the hashed evidence. After the retention period, action parameters and approval comments are redacted while digests and the chain stay intact.
If personal data were written into the hash chain, erasing it would break every later hash. Instead, the stored digest, decisions, approvals and evidence chain are kept, while sensitive parameter values (such as bank details) and approval comments are replaced by "[redacted]" after a tenant-configurable retention period. A legal hold blocks redaction. Redaction is itself an evidence event (action.redacted). Free-text justifications are never written to evidence, and receipts contain no PII. There is also a data-subject export.
Production runs at actescrow.com on a single Ubuntu host with Docker Compose (the pilot profile). A separate staging environment carries the end-to-end tests. Cloud (Azure/AWS/GCP) profiles are planned, not built.
Production at actescrow.com is an engineering pilot on a single Ubuntu host: Docker Compose with the .NET control plane, Keycloak 26 and PostgreSQL 18 behind the host's nginx, using the single-VPS pilot profile. The enforcement gateway is not part of it: it runs on your side. A separate staging environment runs the same stack plus a gateway and a mock ERP for end-to-end tests. Azure/AWS/GCP profiles via OpenTofu are planned and not yet built. We will not describe high availability or managed key custody as available until they are.
No. We make no certification or guaranteed-compliance claims. The product produces evidence that supports oversight requirements.
This release is an engineering vertical slice. We do not claim SOC 2, ISO 27001 or GDPR certification, or guaranteed EU AI Act compliance. What the product provides is technical support for human oversight and record-keeping: enforced approvals, separation of duties, step-up authentication, and verifiable evidence you can hand to your own auditors.
If your agents are read-only, if you only need prompt filtering, or if a simple approval step for one low-risk workflow is enough.
The product is for high-risk, state-changing tool calls such as supplier bank-detail changes and invoice approvals. You probably should not buy it if: (1) your agents only read and summarize and never call write APIs; (2) you only need prompt-injection or content filtering (use a guardrail product); or (3) you have one low-risk workflow where a simple approval message is sufficient and you do not need verifiable evidence.
Exception cases track all seven detector kinds (OutcomeUnknown, ExecutionStale, OutcomeConflict, EvidenceIntegrityConflict, DuplicateSuspected, VerificationOverdue, EvidenceIncomplete); only OutcomeConflict can be resolved manually.
Overview shows live counts for Pending approval, Unknown: needs reconciliation, Conflict: needs review, Open exception cases, and Last scheduled verification. Open cases appear in /exceptions (GET /v1/exceptions) for tenant admins and security reviewers across all seven kinds: OutcomeUnknown, ExecutionStale, OutcomeConflict, EvidenceIntegrityConflict, DuplicateSuspected, VerificationOverdue, and EvidenceIncomplete. Under ADR-0019, only OutcomeConflict accepts manual resolution by a tenant admin with MFA (using target_corrected, target_state_accepted, or escalated_out_of_band and optimistic concurrency version, which writes exception.resolved without retrying the action); all other kinds return 409 exception_requires_reconciliation and close only when reconciliation, verification, or investigation/escalation resolves the underlying state.
The Portal BFF keeps OIDC tokens server-side in PostgreSQL behind an HttpOnly cookie; no tokens are exposed in browser storage.
When you click Sign in, you authenticate with Keycloak (including MFA or passkey step-up when required) and the Portal BFF stores your session encrypted at rest in PostgreSQL behind an HttpOnly cookie. Refreshing the browser or restarting a portal replica keeps you signed in until the session expires, and no bearer tokens are placed in browser storage or copyable by users. Choosing Sign out deletes the server-side BFF session, clears the cookie, and logs you out at Keycloak everywhere.
Per-agent scope restricts which tools, resources, and minor-unit amounts an agent may propose before policy evaluation, with maker-checker approval.
Tenant admins can propose per-agent scope revisions (POST /v1/admin/agents/{agentId}/scopes or /agents in the portal) containing tool and resource wildcard patterns plus optional per-currency minor-unit amount limits. A second tenant admin with MFA must approve the exact documentHash before the revision takes effect. Scope is checked before policy rules: if an active revision does not match the call (or an amount-limited rule is evaluated on a call without an amount in that currency), the control plane fails closed with agent_scope_denied. Agents without an active scope revision fall back to policy evaluation alone.
GET /v1/admin/tenant-export returns a single-snapshot signed bundle of all events, checkpoints, and receipts verifiable with aa-verify bundle.
A tenant admin with MFA can call GET /v1/admin/tenant-export (rate-limited per tenant by RateLimits:TenantExportsPerHour, default 3/hour) to download a single REPEATABLE READ snapshot containing every evidence event, every signed checkpoint, and one aa.receipt.v1 receipt per finished action (Succeeded, Failed, Denied, Expired, Cancelled, Conflict), plus an ES256-signed manifest. Requests above 200,000 events or 5,000 receipts return 409 invalid_state (use paged /v1/evidence/export instead). Using the public anchoring key from GET /v1/evidence/anchoring-key, an auditor verifies the entire bundle offline with aa-verify bundle <file> --public-key <pem>.
Two separate tenant admins request and approve offboarding deletion, redacting PII and disabling agents while keeping hash chains verifiable.
One tenant admin requests offboarding via POST /v1/admin/tenant-deletion with confirmTenantId, and a different tenant admin with MFA approves via POST /v1/admin/tenant-deletion/{id}/decide (within 7 days). Both calls return 409 if any action is on legal hold, within the hold-release cooling-off window, or unfinished (Pending, Approved, Executing, Unknown). On approval, a single transaction redacts action parameter values, justifications, free-text reasons, approval comments/names (via aa_offboard_redact_approvals()), policy/scope decision comments, and webhook targets, switches off all agents, and marks the tenant offboarded (tenant_offboarded). Evidence events, checkpoints, action digests, and pseudonymous OIDC sub actor IDs stay intact so pre- and post-deletion bundles verify.
Run our interactive Policy & Maker-Checker Simulator or compare Agent Action Assurance against 8 industry alternatives.