IRL seals every AI decision before it reaches the exchange — cryptographically, before execution. Self-hosted in your VPC or fully managed. Daily Merkle roots anchored to Bitcoin, so the audit chain verifies without trusting anyone — including us.
Current observability infrastructure captures what autonomous agents did and when. It cannot prove why — or what the agent knew at the moment of decision. This is the gap that regulators are asking about, and that no existing tool closes.
| Capability | Current state | With IRL |
|---|---|---|
| What action was taken | Logged | Logged + sealed |
| When the action occurred | Single timestamp | Bitemporal (valid_time + txn_time) |
| Why the action was taken | Approximate / inferred | Deterministic CognitiveSnapshot |
| What the agent knew at decision time | Not provable | Cryptographically proven via L_t fingerprint |
| Whether constraints were enforced | Not guaranteed | Pre-execution hard halt on violation |
| Which model produced the decision | Not verifiable | Model hash in Multi-Agent Registry |
| Whether execution matched reasoning | Not tracked | Post-trade verifier with divergence detection |
Every trade produces a cryptographic chain from regime attestation to exchange confirmation. No party can alter any link after the fact without breaking the chain. Authorize is a synchronous pre-execution call — p99 under 3 ms colocated. Built for systematic and mid-frequency desks; if you are racing the tick, IRL is not your tool.
reasoning_hash = SHA-256(RFC 8785 canonical JSON of snapshot)reasoning_hash + trace_id — embedded in exchange order metadata before submission.exchange_tx_id.final_proof = SHA-256(reasoning_hash ‖ exchange_tx_id) — chain closed.Edit a single byte of any sealed trace and every hash downstream stops matching — but the original root is already in a Bitcoin block. No one, including us, can rewrite it. That is the entire trust model, in one loop.
Precision matters more than marketing here. IRL is a commitment scheme with independent timestamping: it does not make dishonesty impossible — it makes it expensive, contemporaneous, and permanent. Here is the exact guarantee, stated the way your auditor will ask for it. Don't take our word for any of it: the verifier is open source (MIT) and the anchor feed is public.
Nobody puts an untested gate in front of live order flow. You don't have to. Run IRL in shadow mode against production traffic — it seals everything and blocks nothing — and run it inside your own perimeter from day one.
Every authorize call is checked, sealed, and written to the ledger — but never denied. Point your agents at IRL today, compare its verdicts against your live behavior for a month, and flip enforcement on only when the evidence says so.
One container in your VPC. Snapshots — features, prompts, hyperparameters — are sealed and stored inside your perimeter, encrypted at rest with per-trace DEKs (local key, AWS KMS, GCP KMS, or HSM). MacroPulse sees nothing. The Bitcoin anchor publishes only a 32-byte Merkle root.
Three demo agents are pre-seeded. Use Swagger UI to run a full authorize → bind-execution cycle in-browser. No API key, no registration.
Native SDKs for Python and TypeScript wrap the IRL REST API with typed models and automatic heartbeat handling. Available on PyPI and npm — no build step required.
import asyncio from irl_sdk import IRLClient, AuthorizeRequest async def trade(): async with IRLClient("https://irl.macropulse.live") as client: result = await client.authorize(AuthorizeRequest( agent_id="agent-42", model_hash_hex="a3f2...", action="Long", asset="BTC-USD", quantity=0.5, notional=32500, )) if result.authorized: place_order(reasoning_hash=result.reasoning_hash) asyncio.run(trade())
import { IRLClient } from "irl-sdk"; const client = new IRLClient({ irlUrl: "https://irl.macropulse.live", apiToken: process.env.IRL_API_TOKEN!, }); const result = await client.authorize({ agent_id: "agent-42", model_hash_hex: "a3f2...", action: "Long", asset: "BTC-USD", quantity: 0.5, notional: 32500, }); if (result.authorized) placeOrder(result.reasoning_hash);
Same API surface at every layer — upgrading never touches your agent code. Full feature lists are in pricing.
IRL's engine is agnostic to the regime source. The MtaClient interface accepts any cryptographically signed signal — MacroPulse's pipeline, your own quant model, or nothing at all. Three modes. Same audit guarantees.
IRL produces evidence that maps directly to specific regulatory requirements — not general "auditability," but the specific proof each framework asks for.
| Requirement | IRL mechanism |
|---|---|
| EU AI Act Art. 12 Requires high-risk AI systems to automatically log events enabling post-market monitoring and incident investigation. Autonomous trading systems are classified as high-risk under Annex III. Phased enforcement begins 2025–2027. Read regulation → — Decision auditability | reasoning_hash = SHA-256(canonical snapshot) |
| EU AI Act Art. 13 Mandates that high-risk AI systems be sufficiently transparent that deployers can understand and interpret outputs. Requires logging of decisions and human oversight capability — including disclosure to regulators on request. Read regulation → — Transparency to regulators | Sealed snapshot disclosure today · ZK proofs on the L3 roadmap |
| SEC Rule 15c3-5 The Market Access Rule requires broker-dealers with market access to implement pre-trade risk controls and supervisory procedures. Firms must have systems to prevent erroneous orders and ensure compliance with applicable regulatory requirements. Read regulation → — Pre-trade risk controls | Policy Engine blocks non-compliant intents before execution |
| MiFID II RTS 6 Requires algorithmic traders to maintain contemporaneous records of all algorithmic orders showing time of creation, modification, cancellation and execution. Records must include the parameters that triggered the order and remain available to regulators for five years. Read regulation → — Contemporaneous recordkeeping | Bitemporal timestamps: valid_time + txn_time, immutable |
| DORA Art. 9 & 10 The Digital Operational Resilience Act requires financial entities to maintain registers of all ICT-supported functions and third-party dependencies, with continuous monitoring and incident classification. Applies to AI systems used in financial decision-making from Jan 2025. Read regulation → — Fleet governance | Multi-Agent Registry: per-agent identity and risk controls |
The value of a sealed reasoning trace is in its existence — not in counting seals. Flat per-agent pricing means compliance scales linearly with your fleet, never with your volume. L1 is operational in under a day.
Fleet discounts — L1 & L2
| Fleet size | Discount |
|---|---|
| 1–5 agents | List price |
| 6–15 agents | −15% |
| 16–30 agents | −25% |
| 31+ agents | −35% (negotiated) |
Add-ons
The API is live. Three demo agents are pre-seeded. Run a full authorize → bind-execution cycle in Swagger UI, then deploy in shadow mode against your own traffic — sealed, never blocked — before any enforcement decision.