How a Tarski expert system works

Tarski keeps a permanent record of every input and derives facts and decisions from it with your rules. It blocks any action that would break an invariant, and Studio shows you why each decision was made.

Every mistake becomes a test

When the system makes a wrong decision in production, you turn that case into a scenario. Your coding agent fixes the rules against it, and the case stays in your test set from then on.

  1. 01

    Find the cause

    Follow the provenance chain from the wrong action back to the observations that produced it. You don't need to read the generated rules.

  2. 02

    Save the case as a scenario

    Promote that timeline to a scenario. It fails until the behavior is fixed, and it fails the same way every time.

  3. 03

    Your coding agent fixes the rules

    The agent changes the rules and runs the scenario on the real engine until it passes.

  4. 04

    Check everything again

    tarski verify re-runs every scenario and checks every invariant. You review the results.

A permanent record at object-storage prices

The observation log is the system's source of truth, so Tarski keeps all of it. The log is stored as sealed, content-addressed segments on object storage, laid out according to your ontology. Semantic indexes let a query skip segments it can't reach.

Provenance, replay, and audits read cold history through the same indexes. The working set kept hot is bounded by what your rules can reach, so it does not grow with the size of your history.

observation log · append-only
o#1039  chat.msg        "any wiggle room on price?"
o#1040  proposal.offer  tahoe · $31,400        ← llm
o#1041  policy.floor    tahoe · $33,900
o#1042  mgr.confirmed   discount_request        ✗ no
─────────────────────────────────────────────
intent  send_offer($31,400)   refused · violates
                              no_offer_below_floor
⊨ model consistent · log sealed · replay exact

Hard limits

You declare the outcomes the system must never produce. Tarski checks every proposed action against them before it runs, and an action that would break one does not run.

Tarski checks the proposed action itself, so the check holds whatever reasoning the LLM used to produce it. A refused action gets a receipt that names the invariant it would have broken.

LLMs suggest, rules decide

Runtime LLMs write to two relay namespaces. A model that reads input, such as a document parser, writes candidate.* facts. A model that recommends actions writes proposal.* actions. Neither becomes a fact or an action until a rule you wrote accepts it.

The loader enforces this by rejecting any rule that derives an accepted fact or an executable intent directly from LLM output. The check runs on the rule graph when the app loads.

See why each decision was made

Every derived fact has recorded links to the observations that caused it. In Studio you follow those links backward: from an action to its intent, to the facts behind the intent, to the observations behind those facts. You don't need to read the generated rules.

effect#e91
send_offer
unexpected
←
intent#i77
offer.ratified
admitted
←
fact
discount.approved
derived · rule r14
←
obs#o1042
mgr.confirmed = no
the cause

Rule r14 checked only that a manager confirmation existed and ignored its value. Promote this timeline to a scenario and give it to your coding agent.

Start with one decision your experts make every day.