Bi-Temporal Event Sourcing

The API Platform
for the AI Era

Capture every business action with full context. Make AI agents auditable and AI-generated code reliable.

Pure functions. Bi-temporal indexing. Complete audit trails. Simple to operate — just containers and S3.

Three ways in

Design. Try. Deploy.

Start where it makes sense for you. The Sandbox is free and running right now.

EvidentSource Designer

Design, then ship.

A visual Event Modeling workspace. Sketch your system as events and state, then generate code for the pure functions that drive it.

Design your system
Free

EvidentSource Sandbox

Try it in your browser.

A free, hosted EvidentSource instance. Point any SDK at it, issue commands, watch state views evolve. No install, no signup for the APIs.

Try the Sandbox

EvidentSource Platform

Run it in your AWS.

Deploy the full platform to your own AWS account via AWS Marketplace. Just containers and S3 — your data, your cloud, out of scope for your audits.

Read the docs

Event Sourcing for
the Agentic Era

A bi-temporal event sourcing platform where every business action is captured as an immutable event, indexed for query across multiple dimensions, and materialized into consistent state views via pure-function WebAssembly components.

AI-Ready by Design

Decision traces, not snapshots

AI agents need the full business narrative, not just current state. EvidentSource captures every action with complete context — what happened, when, why, under what policy. Full context before acting, complete auditability after.

Pure Functions, Not Complexity

The pit of success architecture

Your entire programming model is two pure functions: decide() and evolve(). No distributed transactions, no eventual consistency puzzles. Junior developers, offshore teams, and AI coding agents all produce correct code — the architecture makes it hard to do the wrong thing.

Simple to Operate

Just containers and S3

No Kafka cluster to babysit. No relational database to tune. EvidentSource runs as a container with S3 for storage — that's it. Deploy to your AWS account via AWS Marketplace. Your data stays in your infrastructure, out of scope for your audits. Built on open standards (CloudEvents, WASM Component Model) so nothing locks you in.

Your entire programming model

Two pure functions. That's it.

todo.ts
// decide(): Handle command, query state, return events
export const decide = (db, command) => {
  const todo = db.viewState("single-todo", { todoId: command.todoId });

  if (!todo) throw StateChangeError.notFound("Todo not found");

  const eventType = todo.completed ? "TodoUncompleted" : "TodoCompleted";

  return {
    events: [{ type: eventType, subject: command.todoId }],
    conditions: [unchangedSince(command.todoId, todo.revision)]
  };
};

// evolve(): Apply events to state
export const evolve = (state, event) => {
  switch (event.type) {
    case "TodoCreated":
      return { ...state, todos: [...state.todos, event.data] };
    case "TodoCompleted":
      return updateTodo(state, event.todoId, { completed: true });
    case "TodoDeleted":
      return { ...state, todos: state.todos.filter(t => t.id !== event.todoId) };
  }
};

What Makes Us
Different

Not just another event store. Architectural choices that create defensible advantages no competitor can easily replicate.

Bi-Temporal Indexing

"What did we know, and when did we know it?" Query both transaction time and effective time natively.

Three-Dimensional Indexing

Events indexed by stream, subject, and event type — each dimension queryable bi-temporally.

Containers + S3. That's the stack.

Rust core + WASM components in a single container. S3 for durable storage via SlateDB. No GC pauses, no Kafka cluster to run — streaming is built in.

OpenTelemetry Native

Distributed tracing from day one. Jaeger-compatible. Know what's happening before users complain.

APIs IN

REST gRPC SDK

PURE FUNCTIONS (WASM)

decide() evolve()

STORAGE

S3 (SlateDB)

KAFKA OUT

Built-in

Built for Systems Where
Decisions Matter

Whether you're building AI-first products, modernizing core banking, or escaping legacy systems — EvidentSource is the platform.

Agentic Systems

AI agents are becoming business actors — booking flights, processing claims, executing trades. They need decision traces before acting and complete auditability after.

  • Full context before acting
  • Complete audit trail after
  • Explainable AI decisions

Core Banking

Event sourcing is how modern banking should work. Working examples include high-yield savings accounts with compound interest, installment loans, and double-entry general ledgers.

  • Complete audit trails
  • Bi-temporal queries
  • SOX/FINRA compliant

Legacy Modernization

LLMs have unlocked cost-effective migration from mainframes and legacy systems. Pure functions are ideal LLM targets. 10x-100x cheaper than traditional approaches.

  • LLM-assisted migration
  • Pure function targets
  • Business logic preserved
1000+

TPS per database

<100ms

Write latency

0

GC pauses

Start in the Sandbox.

Issue a command. Read a state view. Watch an event trace appear. No install required — the Sandbox is a public EvidentSource instance running right now.

Try the Sandbox

Free hosted EvidentSource. Point any SDK at it.

Open sandbox

Model in Designer

Draw your system, generate the code. Free to use.

Open Designer

Run it locally

Single container, no external dependencies.

docker run -p 3000:3000 -p 50051:50051 evidentsource/evidentsource-dev:latest