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.
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, and produces the same evidence, before it can create consequence. AiGentsy is not another agent framework; it is the gate infrastructure around autonomous work.
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.
See this workflow in the Enterprise Vault →Path B · Your agent
Attach AiGentsy to your existing agents
Keep your CrewAI, LangGraph, MCP, coding agent, LLM workflow, or API automation — your attached actor. AiGentsy wraps the output with mandate + evidence metadata, gates the decision, exports a ProofPack, and verifies offline. No framework to replace.
See this workflow in the Enterprise Vault →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 Enterprise Vault →The Enterprise Package
You bring one consequential workflow. You receive the gate around it, the Vault that operates it, and portable evidence for everything it decides.
Acceptance Gate
Accept / reject / escalate / retry before consequence. The reason travels verbatim into the signed record.
Enterprise Vault
Your workflow-shaped operating shell for governed agents, decisions, authorization, ProofPacks, verification, 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. Bring any model. Bring any agent.
Proof + Verify
Portable ProofPacks and offline verification — the verifier runs anywhere your auditor runs Python. Tamper any byte and verification fails.
Operator inspection
A public read-only operator view of the same lifecycle, alongside the Vault your team operates.
Consequence Memory
The read-only causal trail of allowed, blocked, held, and settled outcomes — non-custodial.
Live pilot surfaces
Everything below is running today — both agent paths, ProofPack export, the offline verifier, tamper failure, and the full decision and consequence branches.
Open the Enterprise Vault → Open Consequence Console Verify a ProofPack View integrationsCurrent 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.
What the Vault Holds Today
What your team can operate and inspect — the objects and views inside your Enterprise Vault.
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.
Diligence · 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.
Verification establishes integrity, provenance, signatures, and event-chain consistency — not real-world truth. A verified record may represent an acceptance or a rejection. Standards detail → · Mandate semantics (as-built) →
Settlement and Consequence Memory
One lifecycle, two distinct things: Settlement is what an approved consequence is allowed to do downstream. Consequence Memory is the read-only causal trail of what was decided and what followed.
Mandate
The rules a deal must satisfy before work can be handed off. Recorded; enforced before proof.
Proof
ProofPack v2: portable, signed, offline-verifiable. Carries the mandate, the work, and the chain of custody.
Acceptance
Counterparty accepts, rejects, or disputes — with a reason that travels in the record. No automatic pass.
Settlement
Value or action moves only after acceptance, and only within exact authorization. Your systems or provider execute it. The signed OutcomeReceipt records the resulting state; refusals are recorded too.
Consequence Memory · read-only
What the causal trail remembers: what was mandated, what evidence existed, what policy decided, what was accepted, what was exactly authorized, what the external system reported, what was reconciled, and what your organization now remembers. Each record carries a decision-envelope reference that shapes future Recall.
Consequence Memory is a read-only projection — it does not predict, score, or enforce, and it is not a new learning layer. OutcomeReceipt is an attestation; reconciliation is a later observation. AiGentsy does not train on customer model content by default. Items are labeled measured, verifier-backed, platform-attested, or demo/reference.
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.
Savings Trace
Run an AI output through the acceptance gate and see what AiGentsy prevented, reused, shortened, escalated, or verified before consequence moved — potential exposure gated, evidence gaps identified, policy paths reused, downstream actions held or blocked, and the signed audit artifact behind each decision.
Every item is labeled measured, estimated, or demo/reference. Measured benchmark, not a production-customer claim. Deterministic demo fixtures only — no live LLM call. Cross-model benchmarking and provider-measured savings remain operator-only.
What AiGentsy holds — and what it never touches
AiGentsy governs the consequence without owning or operating the thing being governed. That boundary is architectural, not a policy promise — and it is why the evidence stays portable and you can leave at any time.
AiGentsy retains the causal trail
- Mandates and actor references
- Policy inputs and Acceptance records
- Authorization metadata
- Identifiers, hashes, signatures, event-chain evidence
- ProofPacks and OutcomeReceipts
- Reconciliation observations
- Consequence Memory projections
You or your provider own and operate
- Agents and models
- Credentials and private keys
- Compute and execution environments
- Documents and customer artifacts
- Target systems and callbacks
- Provider accounts
- Funds and settlement assets
- External result payloads
No custody of funds, compute, documents, or private keys. No blockchain. No vendor lock-in — the offline verifier runs anywhere your auditor runs Python. Authorization metadata does not itself perform the external action, and AiGentsy does not claim atomic external execution.
Optional: AiGentsy Recall, powered by HoverStack
Optional. Recall is governed reuse of prior attested work: for exact-repeat work it can return a proof-bound prior output instead of recomputing it, while refusing unsafe near-repeats and drift. Every reuse decision is signed into a Governed Economic Proof bound to the ProofPack — governance and evidence stay intact.
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). Measured benchmark, not a production-customer claim.
Recall is not a prerequisite for the Gate or the Vault. HoverStack remains broader than Recall alone: compute governance, Decision Envelopes, negative compute, workflow execution, benchmark validation, and attestation paths. Enterprise licensing is available for high-volume or multi-agent workflows.
HoverStack Details Licensing InquiryWhere AiGentsy sits in your stack
Keep your agents, models, and workflows. Attach AiGentsy at the consequence boundary — through existing APIs, the SDK, MCP, or adapters — and your Vault becomes the workflow-shaped surface your team operates. External execution stays in your systems or your provider's.
Formation: intent becomes accepted agreement
Execution: coordination, resources, and proof
Settlement: value moves when conditions are met
Continuity: trust, lineage, and organization persist
How to Start an Enterprise Pilot
Bring one consequential workflow. We map its policy and Acceptance boundary, run it in demonstration or shadow mode first, and produce the signed evidence your auditors need. You keep your agents, systems, credentials, and execution. Success is a decision your team can defend and a record anyone can verify without us. Nothing enforces in production by default; deployment is narrow and contract-led.
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: Operate it in your Vault: the Enterprise Vault
Agents can be consequence-aware from scaffold: acceptance hooks, ProofPack export, verifier link, Savings Trace, and Consequence Memory are present from line one of the aigentsy create-agent scaffold — nothing new to build to start operating under the acceptance gate.
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.