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.
- 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.
- 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.
- 03
Your coding agent fixes the rules
The agent changes the rules and runs the scenario on the real engine until it passes.
- 04
Check everything again
tarski verifyre-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.
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.
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.
Your coding agent writes the rules
Tarski doesn't include a coding agent. It provides the docs, skills, and checks that let Claude Code, Codex, Devin, or another coding agent scaffold, write, verify, and deploy a Tarski app.
Start from a pattern
Chat, sensor, decision, and identity patterns each scaffold a small working app that passes verify on the first run.
Feedback on every change
Scenario results, invariant checks, and load-time errors for each rule the agent writes.
Feedback on structure
Module maps, composition verdicts, and coverage reports tell the agent how to split a system into modules. The boundaries are computed from the ontology.
All three commands ship in the Tarski CLI. CLI reference