The immutable ledger for the agentic age

Every enterprise system you've ever used has a dirty secret: it lies. Not maliciously — structurally. Relational databases overwrite state. REST APIs return snapshots that were stale before the response hit the wire. ERPs batch-process reality into something palatable for quarterly reports. And somewhere in the gap between what happened and what got recorded, value leaks out.

Now multiply that by autonomous agents. Agents that buy, sell, route, approve, reject, escalate, and reconcile — thousands of times per second, across every system in your stack. If your system of record is a mutable database that agents can read and write, you don't have a system of record. You have a shared hallucination.

That's why we built TES.

An append-only event spine for everything that matters

TES — the Thing Event System — is an immutable, append-only event ledger purpose-built for enterprises operating in the agentic era. Every entity your business touches — a physical product, a financial instrument, a customer interaction, a regulatory filing, an agent decision — emits events into TES. Those events are permanent. They cannot be modified, deleted, or rewritten. They form a cryptographically verifiable, temporally ordered record of everything that has ever happened to anything your organisation cares about.

If event sourcing and CQRS had a child that was raised by enterprise compliance teams and trained on every supply chain failure mode of the last decade — that's TES.

But here's what makes it different from every other event-sourcing framework you've evaluated and shelved: TES was designed from day one as the canonical system of record for AI agents. Not retrofitted. Not "AI-compatible." Agent-native.

// A single TES event — immutable, append-only, cryptographically hashed
await tes.emit({
  thing_id: "urn:tes:thing:pallet-EU-29571",
  event_type: "logistics.custody_transfer",
  holder_from: "holder:warehouse-rotterdam",
  holder_to: "holder:carrier-dhl-express",
  location: "loc:rotterdam-port-terminal-7",
  timestamp: "2026-03-18T14:32:01.847Z",
  metadata: {
    weight_kg: 1247.3,
    seal_id: "NL-2026-881204",
    temperature_c: 4.2,
    chain_of_custody_hash: "sha256:a4f8e..."
  }
});

// That event is now permanent. No UPDATE. No DELETE.
// Every downstream system — AI or human — sees the same truth.

Why not blockchain? Because you're not solving the wrong problem.

We get this question constantly. The answer is simple: blockchains are consensus mechanisms for adversarial networks. Enterprise environments are not adversarial networks. You don't need Byzantine fault tolerance between your warehouse management system and your ERP. You need a system that is fast (sub-10ms writes), scalable (millions of events per second), and provides the immutability guarantees that matter — append-only semantics, cryptographic hashing, tamper-evident audit trails — without the absurd overhead of distributed consensus.

TES delivers immutability at the infrastructure layer. Events are written once, hashed, and indexed. The hash chain provides tamper evidence. The append-only constraint is enforced at the storage engine level, not by social consensus. The result: blockchain-grade auditability at database-grade performance.

To put numbers on it: where a typical enterprise blockchain gives you 10-100 TPS with second-scale latency, TES sustains 100,000+ events per second with p99 write latency under 5ms. That's not a rounding error. That's three orders of magnitude. That's the difference between "technically possible" and "production-grade."

Every event is AI-queryable from the moment it lands

Here's the insight that changes everything: most enterprise data wasn't designed to be consumed by language models. It lives in normalised relational schemas that require 12-table JOINs to answer a simple question. It's scattered across SaaS tools with incompatible APIs. It's in CSV exports that someone emailed last Tuesday.

TES events are structured, self-describing, and instantly available through Model Context Protocol (MCP) tooling. When an AI agent needs to understand the state of any entity in your system, it doesn't need a database connection string, an ORM, or a data engineering team to build a pipeline. It calls a single MCP tool, and TES returns the complete, consistent, real-time truth.

// An AI agent queries TES via MCP (Model Context Protocol)
const result = await mcp.tool("tes_query", {
  entity: "thing:pallet-EU-29571",
  projection: "current_state",
  include: ["custody_chain", "location_history", "compliance_flags"]
});

// result.current_holder → "holder:carrier-dhl-express"
// result.location → "loc:rotterdam-port-terminal-7"
// result.custody_transfers → 4
// result.compliance.eu_deforestation_reg → "COMPLIANT"
// result.time_in_transit → "2h 14m"

// The agent didn't need a database connection.
// It didn't need to parse CSVs or call 6 different APIs.
// One query. Complete truth. Milliseconds.

This is not a wrapper around a REST API. TES projections are materialised views computed from the event stream in real time. The current state of any entity is always derivable from its event history. There is no impedance mismatch between "what happened" and "what the system shows." They are the same thing.

For enterprises sitting on decades of siloed data, this is transformative. TES doesn't replace your existing systems — it sits alongside them, capturing events from every source and making them available as a unified, AI-queryable substrate. Your agents can generate insights, build dashboards, detect anomalies, and make decisions on data that was previously invisible, fragmented, or locked inside systems that predate the iPhone.

Agents without a system of record are just expensive random number generators

The agentic future everyone's fundraising around has a massive infrastructure gap. We're building agents that can reason, plan, and execute — but they're operating on data architectures from 2005. They can call APIs, sure. But which API is authoritative? When two systems disagree, which one is right? When an agent makes a decision, where is that decision recorded? Who audits it? Can you replay the exact state the agent saw when it made that call?

With TES, every agent decision is itself an event in the ledger. The agent's reasoning, the data it consumed, the action it took — all captured, all immutable, all auditable. When a regulator asks "why did your AI system reject this insurance claim?" you don't grep through log files. You query the event stream. The answer is right there, cryptographically timestamped, with a full causal chain back to the source events.

// Agent autonomously detects anomaly and acts on TES data
const anomaly = await agent.analyze({
  stream: "tes.events.logistics.*",
  window: "24h",
  pattern: "temperature_deviation"
});

// anomaly.detected → true
// anomaly.thing → "thing:pharma-shipment-8891"
// anomaly.deviation → "+3.7°C above threshold for 47 minutes"
// anomaly.risk_score → 0.92

// Agent emits its own decision event back into TES
await tes.emit({
  thing_id: "thing:pharma-shipment-8891",
  event_type: "agent.compliance.hold_initiated",
  agent_id: "agent:cold-chain-monitor-v3",
  reason: "Temperature excursion detected — regulatory hold pending review",
  evidence: anomaly.event_ids,  // Immutable references to source events
  human_escalation: true
});

// The agent's decision is now part of the permanent record.
// Auditable. Traceable. Defensible.

This is not optional complexity. The EU AI Act requires precisely this level of traceability for high-risk AI systems. Colorado's AI Act demands documented decision audit trails. As agent autonomy increases, regulatory requirements for explainability and accountability are only going to intensify. TES makes compliance a byproduct of architecture, not an afterthought bolted on by a GRC team.

Physical. Digital. Financial. All of it.

TES doesn't care whether the thing being tracked is a shipping container, a software license, or a derivatives trade. The event model is domain-agnostic by design:

Every one of these event types feeds into the same projection engine. Cross-domain queries that would require a data warehouse, an ETL pipeline, and a BI team become single MCP calls. "Show me every physical product that was involved in a financial transaction flagged by an agent in the last 30 days" — that's one query. Not a Jira ticket for the data team.

// TES projections — real-time materialized views from event streams
const dashboard = await tes.project({
  scope: "org:acme-logistics",
  projections: [
    "inventory.current_state",
    "compliance.regulatory_status",
    "agents.decision_log",
    "financial.transaction_ledger"
  ],
  time_range: "last_30d"
});

// dashboard.inventory.items_tracked → 847,291
// dashboard.compliance.audit_score → 99.7
// dashboard.agents.decisions_made → 12,847
// dashboard.agents.human_overrides → 3  (0.02%)
// dashboard.financial.transactions_value → "$42.8M"
// dashboard.financial.reconciliation_errors → 0

The architecture

TES is built on a small number of powerful primitives that compose cleanly:

The bet we're making

Every significant platform shift creates a new system-of-record layer. Relational databases won the client-server era. Cloud data warehouses won the SaaS era. We believe immutable event ledgers — not blockchains, not data lakes, not another flavour of Postgres — will be the system-of-record layer for the agentic era.

Here's why: when agents are making decisions at machine speed across every function of your business, the ability to capture, replay, audit, and query every decision and its causal context is not a nice-to-have. It's the foundational infrastructure. Without it, you get autonomous systems operating on mutable state with no audit trail — which is another way of saying you get catastrophic risk with no recourse.

TES is that foundational infrastructure. It's the event spine that agents write to, read from, and reason over. It's the system of record that regulators can trust, auditors can verify, and engineers can build on without worrying about whether the data underneath will shift.

The companies that move first on this will have an extraordinary structural advantage: complete, queryable, AI-native records of everything their business has ever done. The ones that don't will spend the next decade retrofitting governance onto systems that were never designed for it.

We know which side of that we're building for.