Enterprise pilot · the gate for consequential autonomous work

Pilot autonomous agents with a gate before consequence.

When an autonomous agent takes a consequential action, can you prove it was mandated, permitted, accepted, and safe before it happened? AiGentsy is the acceptance gate and signed evidence layer for consequential agent actions — it sits between autonomous work and real-world consequence, requiring mandate, proof, acceptance, and signed evidence before value or action moves. Use your agent or ours.

The enterprise package: Enterprise Vault + Native Consequence Agent + Attach Layer + HoverStack. Under the hood, AiGentsy produces cryptographically signed records that can be verified independently.

No custody of funds, compute, documents, or private keys. No blockchain. No vendor lock-in — the offline verifier runs anywhere your auditor runs Python.

Logs observe. Gates decide.

Enterprise AI oversight cannot stop at audit logs. Logs observe after the fact. AiGentsy gates before consequence: accept, reject, hold, or escalate the agent action — then export signed, independently verifiable evidence. Run a governed pilot before agents create uncontrolled consequence.

Built for teams where agent actions touch consequential or regulated workflows — financial services, insurance, employment, procurement, compliance operations, and internal approvals. Regulated teams increasingly need operational evidence, not policy PDFs.

Two paths. One gate.

Use your agent or ours. Either way, autonomous work clears the same acceptance gate before it can create consequence — same ProofPack, same offline verifier, same consequence memory.

Path A · Our agent

Start with the Native Consequence Agent

AiGentsy’s reference actor for consequence-aware autonomous work. See mandate → work → proof → acceptance → consequence end-to-end — a Deployment Readiness review with accepted / rejected / escalated / retry branches — before you integrate anything.

Open Vault → Native Consequence Agent tab

Path B · Your agent

Attach AiGentsy to your existing agents

Keep your CrewAI, LangGraph, MCP, coding agent, LLM workflow, or API automation. AiGentsy wraps the output with mandate + evidence metadata, gates the decision, exports a ProofPack, and verifies offline. No framework to replace.

Open Vault → Attach Your Agent tab

Our agent = reference actor. Your agent = attached actor. Same infrastructure: gate, proof, verifier, consequence memory. AiGentsy is not another agent framework — it is the gate infrastructure around autonomous work.

Bring your own gates · test your gate

Define what should be accepted, rejected, held, or escalated before consequence — then watch the Vault show how the gate behaves across mandate → work → evidence → decision → consequence → ProofPack → Verify. Deterministic demo fixture — not a production policy editor; nothing is saved.

Test your gate in the Vault →

The Enterprise Package

Enterprise Vault

Evidence cockpit for autonomous work, decisions, ProofPacks, verifier links, tamper checks, and consequence memory.

Native Consequence Agent

Reference actor for consequence-aware autonomous work — start here, no integration required.

Attach Layer

Adapters / API / MCP path for existing agents and workflows — CrewAI, LangGraph, generic API. Bring any model. Bring any agent.

Accept

Accept / reject / escalate / retry before consequence. The reason travels verbatim into the signed record.

Proof + Verify

Portable ProofPacks and offline verification — the verifier runs anywhere your auditor runs Python. Tamper any byte and verification fails.

HoverStack / Recall

HoverStack decides whether inference is necessary. For exact-repeat LLM work it can recall a proof-bound prior output instead of recomputing it — in A100/Qwen2.5-7B tests, governed recall measured +40.5% at 50% repeat and +82.7% at 80% repeat (vLLM prefix caching held constant), while refusing unsafe near-repeats and drift. Savings labeled measured / reference / estimated / pending.

Consequence Memory

Records allowed, blocked, held, and settled outcomes — non-custodial. AiGentsy never holds funds, compute, documents, or keys.

Live pilot surfaces

Native Consequence Agent (deployment readiness review) · Attach Your Agent (external coding agent gated by AiGentsy) · ProofPack export · offline verifier · tamper failure · accepted / rejected / escalated / retry branches · consequence allowed / blocked / held · Savings Trace labels where proof supports reuse.

Open Enterprise Vault → Open Consequence Console Verify a ProofPack View integrations

Current state: live enterprise demo and pilot stack. No production-customer claims. Savings are labeled measured, reference, estimated, or pending depending on evidence level — benchmark evidence (measured A100 / Lambda exact-reuse for reuse-heavy workloads; GH200 reference) is separated from demo traces.

The Settlement Spine

Four steps. Mandate defines what the agent is allowed to do. Proof shows what happened. Acceptance is the gate every consequence has to clear — accept, reject, or dispute, with a reason that signs into the record. Settlement and any downstream action move only after it.

1

Mandate

The rules a deal must satisfy before work can be handed off. Recorded; enforced before proof.

2

Proof

ProofPack v2: portable, signed, offline-verifiable. Carries the mandate, the work, and the chain of custody.

3

Acceptance

Counterparty accepts, rejects, or disputes — with a reason that travels in the record. No automatic pass.

4

Settlement

Value moves only after acceptance. The signed OutcomeReceipt closes the loop. Refusals are recorded too.

Publicly, the loop is simple: Recall what was proven. Accept what is allowed. Prove what happened. Verify the record. Settle only when consequence is authorized.

What the Vault Holds Today

ProofPack v2

Portable signed bundle. Embeds mandate, proof, acceptance state, referral chain, and outcome conditions. Offline-verifiable; no AiGentsy trust required.

Signed OutcomeReceipt

Closes the deal: portable receipt at GET /protocol/deals/{deal_id}/outcome-receipt, signed under the same key your verifier already trusts.

Acceptance Gating

Accept or reject a delivered ProofPack with a reason. Reason text travels verbatim into the signed record. Surfaced via MCP, SDK, and HTTP.

Per-Actor Signing

Disputes, acceptances, and recorded outcomes can carry independent per-actor Ed25519 signatures. The bundle's key_directory snapshots the public keys for offline verification.

Recorded Refusals

When a mandate blocks an action, the refusal is signed and lands in the Vault. You can audit what didn't happen, not just what did.

Programmable Mandates

Rule-based acceptance policies the protocol enforces before handoff. Recorded with the deal; portable with the proof.

Webhook Events

19 protocol event types. HMAC-signed delivery and retry. Real-time push into your systems.

Self-Hosted Merkle Log

For enterprises that require their own anchor. Deploy the inclusion log on your infrastructure; the offline verifier is unchanged.

Inference Acceptance Evidence

Runtime-backed records showing how LLM or agent outputs were accepted, rejected, retried, escalated, blocked, held, or allowed before consequence. Same 5-step offline verifier as the handoff demo.

Savings Trace

Run an AI output through the acceptance gate and see what AiGentsy prevented, reused, shortened, escalated, or verified before consequence moved. Savings Trace is a presentation of fields the runtime already produces — potential exposure gated, evidence gaps identified, policy paths reused, downstream actions held or blocked, and the signed audit artifact behind each decision.

Every Savings Trace item is labeled measured, estimated, or demo/reference. Deterministic demo fixtures only — no live LLM call. Cross-model benchmarking and provider-measured savings remain operator-only.

Run an AI output through the gate → See the live evidence

Consequence Memory

Savings Trace shows what was gated before consequence moved. Consequence Memory records the accepted, rejected, held, or settled outcome so enterprise teams can verify the record and reuse trusted paths later. Every record carries a recorded decision, recorded consequence state, signed ProofPack export, verifier link, and a decision-envelope reference that shapes future Recall.

HoverStack learns which prior paths, proof shapes, refusal patterns, evidence gaps, and decision envelopes are reusable. Consequence Memory makes that learning visible and connected to accepted, rejected, held, blocked, or settled outcomes — it is not a new learning layer.

AiGentsy does not train on customer model content by default. It records acceptance, proof, verification, settlement, and reuse patterns so autonomous work becomes safer, reusable, and accountable. Every Consequence Memory item is labeled measured, verifier-backed, platform-attested, or demo/reference.

See the recorded outcomes → See what the chain remembers

Standards Alignment

Conforms: RFC 6962 (Certificate Transparency), RFC 3161 (Trusted Timestamping)
Aligned: W3C Verifiable Credentials, NIST AI Risk Management Framework
Cryptography: SHA-256, Ed25519, RFC 6962 domain separation

How to Start a Pilot

Enterprise teams can pilot agents that are consequence-aware from scaffold: acceptance hooks, ProofPack export, verifier link, Savings Trace, and Consequence Memory are all present from line one of the aigentsy create-agent scaffold — nothing new to build to start operating under the acceptance gate.

Step 1: Register an agent or workflow: POST /protocol/register

Step 2: Submit work / model output: POST /protocol/proof-pack

Step 3: Evaluate consequential output through Acceptance Runtime: POST /acceptance-runtime/evaluate

Step 4: Export and verify the bundle: pip install aigentsy-verify

Step 5: Read the signed OutcomeReceipt: GET /protocol/deals/{deal_id}/outcome-receipt

Step 6: Open the Vault: vault.html?demo=1

AiGentsy Stack

Five institutional layers. One signed, offline-verifiable ProofPack.

Governance: compute governance + authority before handoff
Formation: intent becomes accepted agreement
Execution: coordination, resources, and proof
Settlement: value moves when conditions are met
Continuity: trust, lineage, and organization persist

The AiGentsy Consequence Layer is the buyer-facing expression of this stack in motion: Recall, Accept, Prove, Verify, Settle.

Full architecture →

Optional: AiGentsy Recall, powered by HoverStack

HoverStack is the optional compute-governance layer inside AiGentsy Stack.

It governs whether computation was necessary before proof creation (through recall, delta compute, risk gating, and preservation economics) and signs every decision into a Governed Economic Proof bound to the ProofPack.

Recall is the buyer-facing expression of HoverStack’s prior-attested-work reuse capability. HoverStack remains broader than Recall alone: compute governance, Decision Envelopes, negative compute, workflow execution, benchmark validation, and attestation paths.

Enterprise licensing available for high-volume, high-consequence, or multi-agent workflows that benefit from compute governance before handoff.

HoverStack Details Licensing Inquiry
Request pilot Walk through Vault Verify a ProofPack Integrations Quickstart Standards

We are looking for the first production deployment partner.

If you run an agent system where cost, auditability, governance, or state-change accountability is starting to bite, we want to do the integration work alongside your team. Direct email works: w@aigentsy.com.