TarskiTarski/ docsJoin the waitlist

Determinism & replay

What Tarski's guarantees claim (byte-exact replay, dual-engine parity, query determinism, index neutrality, and hosted/local parity) and how each one is proven.

Each of Tarski’s determinism claims is enforced by an executable gate. This page states what each claim covers and how it is checked.

Byte-exact replay

Facts are never written directly. Tarski derives them by evaluating an append-only observation log with a digest-identified evaluator. A clean-database replay of recorded observations reproduces the same derived model: the same facts, intents, provenance edges, and checkpoint digests. Resuming from a checkpoint produces the same result as a clean replay, and multi-hop agent deliberations replay with identical digests from a clean store.

Two engines with identical output

Evaluation runs on the incremental (semi-naive) engine by default, so work scales with the size of each change and does not grow with the length of history. The naive full-recomputation engine remains the correctness authority, the verification engine, and the rollback target.

The two engines must produce bit-identical canonical output: facts, intents, assertions, retractions, contradictions, invariant verdicts, provenance edges with exact justification sets, and checkpoint digests. Output that is only equivalent does not meet this contract.

tarski verify --cross-engines

replays every selected fixture through both engines and fails on any divergence. The same parity harness runs continuously in CI over every fixture-bearing example and is release-blocking. Delta-proportionality (the incremental engine doing far less work on warm updates) is also enforced by a CI regression floor.

If you need it, TARSKI_EVALUATOR_ENGINE=naive selects the naive engine for a process. Switching needs no data migration, because incremental carry state is held only in memory. If the incremental path errors, Tarski automatically retries once with the naive engine and records the reason.

Query determinism

A query result is a pure function of the canonical query IR, its bindings, the snapshot identity (lineage_id, evaluator_digest, committed_head), and the caller’s projection. Re-execution reproduces the same result_digest byte for byte, explain artifacts are digest-stable, and the CLI, API, and MCP doors produce byte-identical results for the same query at the same head. Denials are byte-equal on empty and seeded stores, so a denial cannot leak whether hidden data exists.

Index neutrality

Indexes affect performance and nothing else. Index presence, absence, or rebuild never changes query results, derived facts, or any canonical digest. Tarski tests this with enabled-versus-dropped digest comparison, a three-state corpus parity gate, and crash-recovery kill tests. Covering index families are derived automatically from your app’s declared workload, and tarski index drop is always safe. See the CLI reference.

Hosted/local parity

One semantic runtime contract spans local evaluation, the shadow reference evaluator, managed Cloud’s evaluation guest, BYOC, and entitled full-local hosts. For one frozen evaluation package and observation history, all accepted hosts derive the same canonical tuples with provenance. Packages that cannot load are refused at admission, which happens at deploy time and before the first production event.

Hosted query parity is certified. Before capability discovery reports query operations as available, parity receipts compare canonical rows, ordering, digests, support witnesses, typed denials, and redaction state across authorities. A hosted lineage’s health reports “observation accepted” separately from “projection committed” (committed / pending / trapped). A trapped lineage does not lose data: the log is immutable, and a corrected evaluator replays it.

Provider record/replay

External provider envelopes (HTTP, LLM) are captured with redaction and replay identity, so LLM-assisted behavior verifies deterministically without live provider state. Model context is assembled from digest-stamped sections whose digests are included in the provider request digest, so a capture envelope proves byte for byte what a model saw.

The authority hierarchy

  • Engine level: the naive evaluator is the correctness authority, and the incremental engine must match it bit-identically.
  • Activation level: exactly one committed activation per lineage may execute effects. Shadow and compare evaluators derive facts and intents but cannot execute effects.
  • Runtime level: managed Cloud (or your accepted BYOC/enterprise/local authority) is the semantic authority for current evidence. After an app is hosted, local replay is diagnostic parity evidence and does not carry production effect authority.