The platform for bulletproof agentic backends
Software is collapsing into a short pipeline: intent in, running system out. Tarski is the layer in between that a human can still check — Scenarios, invariants, and provenance, enforced by a deterministic logic engine. You approve the contract and its evidence. Never ten thousand generated lines.
One platform. Two readings.
Both are product lines.
Backends written by agents
Claude Code, Devin, or any capable agent authors dh against the Scenarios and invariants you declared. Verification runs the real evaluator — no glue code, no drift. You review the contract and its evidence, never generated internals.
Scenarios, the behavioral contract →Backends that contain agents
At runtime, LLMs are fallible tools behind relays — never drivers. A model may propose; only the engine admits. Every intent is checked satisfiable against your invariants before anything touches the world.
Containment, structurally →The readings close into a loop: provenance pins a runtime misbehavior to its exact observations · the counterexample becomes a fixture · an authoring agent iterates until it passes · verification confirms the fix. Production feeds development through one artifact chain.
The human-checkable contract layer
Three artifacts, each written in the language of the person whose judgment it needs. Together they are what you approve — and the engine enforces them, not a review meeting.
Scenarios
Given this timeline of events, the world must look exactly like this. The most natural artifact a PM or domain expert can review — executed directly by the production evaluator.
scenario "refund above policy"
given refund.requested $1,900
policy.auto_limit $500
expect refund.state = held
effects.sent = noneInvariants
Named hard stops on states the business must never reach — exactly what a risk or security officer signs off. Checked by the engine at every fixpoint, not in a meeting.
invariant no_offer_below_floor
never offer.price
< vehicle.floor_price
checked at every fixpointProvenance
After the application ships, every fact and effect traces back to the observations that caused it. Debug an agent by following the line — without reading its generated logic.
effect#e91 send_offer ← intent#i77 admitted ← fact offer.approved ← obs#o1042 mgr.confirmed
There is no glue gap. A Scenario is not a description of a test — it is the test, executed by the same deterministic evaluator that runs production, compared exactly. The scenario is the test; the test is the contract; the contract binds the running system.
State is never mutated.
It is computed.
Application state is a model derived deterministically from an immutable observation log. Correctness, provenance, and replay are consequences of the mathematics — not aspirations of the implementation.
Observation log
Everything that happens is appended to an immutable log. Nothing is overwritten. Nothing is forgotten.
Derived model
A bounded logic engine computes every fact from the log. Same inputs, same world. Replay is exact.
Intents
Agents and services emit intents. LLM output stays staged behind candidate.* and proposal.* relays until a rule you wrote promotes it.
Admitted effects
Every intent is checked satisfiable against your invariants. Only transitions that hold touch the world. The rest are refused — with receipts.
The evidence, not the vibes
tarski verify runs every Scenario against the real evaluator and checks every invariant at every fixpoint. Green means the contract holds — for the whole declared corpus, deterministically.
This is what your agent iterates against, and what you approve. Statements, not promises.
Determinism is table stakes.
The difference is what you can check.
Deterministic backends made replay respectable. Tarski's differentiators are the contract layer, containment, and storage economics.
| Deterministic backends | Tarski | |
|---|---|---|
| State | Mutable documents plus deterministic functions | A model computed from an immutable observation log — replay is byte-exact |
| Behavior contract | Tests you write and maintain by hand | Scenarios executed by the production evaluator — no glue code to drift |
| Hard stops | Application code, best effort | Named invariants, checked by the engine at every fixpoint |
| Debugging | Logs and breakpoints | Provenance edges from any fact or effect back to its observations |
| Runtime LLMs | Bring your own agent loop | Contained behind relays — every intent checked satisfiable before it acts |
| History | Retention is a cost decision | Everything, forever, at object-storage economics — and still query-serving |
Approve the contract.
Ship the backend.
Tarski is in private beta with design partners building agent-authored and agent-containing systems.