TarskiTarski/ docsJoin the waitlist

What is Tarski?

Tarski is a platform for building expert systems. This page explains what that means and how the pieces fit together.

Tarski is a platform for building expert systems. An expert system makes decisions the way a specialist does: it applies rules to the facts of a case. In a Tarski app, your domain expertise runs as rules on a deterministic engine. LLMs read unstructured input and suggest actions, and only your rules can accept a suggestion. Invariants block any action your experts have ruled out, and every decision traces back to the inputs that caused it.

The name comes from Alfred Tarski, who gave the formal definition of truth in a model. The Knaster–Tarski fixed-point theorem is the basis for how the engine evaluates rules: it computes the model your rules and inputs define, as a fixed point.

How the work is divided

Three parties build and run a Tarski expert system:

  1. Your experts say what correct behavior is. They write it down as scenarios (a sequence of events and the expected outcome) and invariants (outcomes that must never happen). They review evidence and explanations. They don’t need to read generated code.
  2. Your coding agent writes the .ta rules and the deterministic mappers that turn raw input into facts. It runs tarski verify after each change and iterates until every scenario and invariant passes.
  3. LLMs at runtime read documents, chat, and audio, and suggest actions. Their output arrives in the candidate.* and proposal.* relay namespaces and stays there until a rule accepts it. Before any action runs, Tarski checks it against your invariants.

The parts connect. When the system makes a wrong decision in production, provenance shows the observations that caused it. You promote that timeline to a scenario, your coding agent fixes the rules until it passes, and tarski verify checks the fix against every other scenario.

One rule underneath everything

Everything a Tarski app knows or does is computed from its observation history by one evaluator:

observations → typed atom inbox → deterministic evaluator → intent outbox → effects → new observations

State is derived from the log and never mutated in place. The observation log is append-only and is the source of truth. A deterministic mapper turns each observation into typed atoms. The evaluator computes a fixed point over those atoms and your ontology rules, and only committed intent.* rows can be admitted to effects. Effects produce receipts, which re-enter the log as new observations.

Because the whole pipeline is deterministic, replay is exact, verification runs the real evaluator, and every derived fact has provenance edges back to the observations that support it.

What your experts review

Your experts review three artifacts. Each one is short, and each one is executable:

  • Scenarios: a timeline of observations and the exact world that must result. They read like product requirements, and the production evaluator runs them directly. There are no step definitions between the scenario and the engine, which is where classic BDD tests drift.
  • Invariants: named, fail-closed statements about states the system must never reach. The engine checks them over the fully materialized model at every fixpoint.
  • Provenance: the explanation graph. Every fact, decision, intent, and effect traces back to evidence, so you debug by following edges and don’t have to read generated code.

tarski verify runs every scenario on the deterministic evaluator and checks every invariant. A pass means every scenario produced its expected world and every invariant held. It covers the cases you have written down; it is not a proof about all possible inputs.

What Tarski is not

  • A mutable-state database. Tarski does not emulate Postgres or Firestore. State is derived from the log; you never write it in place.
  • An agent framework. Tarski does not ship a coding agent or an orchestration loop. Your agent (Claude Code, Codex, Devin, or another coding tool) writes against Tarski’s contract surface.
  • An identity provider. Your app’s IdP keeps login UI, passwords, and MFA. Tarski verifies credentials at ingress and derives authorization from facts. See Identity & tenancy.

The platform surface

Where to go next

Start with the Quickstart to get an app running in a few minutes. Then read the observation-first pipeline, which explains the model the rest of the docs assume.