A
Apodictateach any model how to think
Over 11,000,000 tests · 0 failures

Any AI, taught how to think.
Free to conjecture — and it reasons through every one.

Apodicta isn’t a bigger model or a better prompt. It’s a discipline that rides on top of any AI — local or frontier — and teaches it how to think instead of what to say. It’s free to make bold conjectures, even unprompted, on its own — and it reasons every conjecture and inference through to your sources. What survives renders; what doesn’t is held — visibly, never silently. Everything it renders is traced to a source and checked two ways — that the source exists, and that it genuinely supports the claim — from a single source to a long, multi-step chain of reasoning. Everyone else retrieves and hopes. Apodicta reasons it through.

Domain-GeneralOne engine, any field — law, medicine, machinery, finance.TESTED · PROVEN
Autonomous or DirectedSets its own aim from the material — or takes yours.TESTED · PROVEN
Self-ConjecturingInvents its own theories, unprompted — then proves each.TESTED · PROVEN
Reasons in StepsChains inference to a conclusion and shows the route.TESTED · PROVEN
Gets Its Own EvidenceReaches out for what it needs when its sources run out.TESTED · PROVEN
Learns & TransfersCarries a lesson to a new, differently-worded problem.TESTED · PROVEN
AbstractsWorks the shape beneath the words, across domains.TESTED · PROVEN
Asks Its Own QuestionsPoses the crux itself — it doesn’t just answer one.TESTED · PROVEN
Never HallucinatesRenders nothing it can’t ground; certifies what it can’t reach.TESTED · PROVEN · EXCEEDS
Why this is different in kind

Three kinds of system.
Only one reasons.

Strip away the branding and almost everything on the market is one of two things — and Apodicta is a third.

The GuessersLLMs · RAG / retrieval · guardrail & verifier scorers · vertical AI on the same models

AI, by its nature, guesses. The frontier models — Claude, ChatGPT, Grok, Gemini — are extraordinary at it, and Apodicta runs on them. But left to decide on their own, they predict the next likely word from the patterns they were trained on: inductive reasoning at its core. That is why even the best of them will, now and then, assert a fact or reach a conclusion that simply does not exist — and induction is fragile, where a single counter-example can be costly, or embarrassing. Retrieval, guardrail scorers, and vertical tools live here too: they fetch neighbors or grade a probability, but the answer is still generated — so it can still be invented.

The probabilities problem. A fair coin lands heads half the time — but would you bet your retirement on a single flip? “Likely right” is not “right.” When the stakes are a case, a diagnosis, or a filing, a probability is not a proof.
The Calculatorsrules engines · hand-built “ontologies”

The usual answer to guessing is a rules engine — a hand-authored set of “if this, then that” mappings, frequently marketed as an “ontology.” It is genuinely deterministic, but the label oversells it: every rule, every table, every answer key is written in advance, by people, for a single domain. It does not reason — it looks up. And it holds only until one line item changes — a new statute, a new field, a case no one anticipated — at which point it breaks, or waits for a human to author the next rule. Every domain has to be hand-built, again.

A clear break
Apodicta — The Ontological Reasoner

Apodicta is built on a true ontology and epistemology. It derives the structure of each problem, per case, from the governing authority itself — no pre-built tables, no answer keys — then reasons freely inside it: hypothesizing its own ideas or testing yours, following the logic in any direction, and proving, or refusing, every step. It is not guessing, and it is not looking up. It reasons — across any domain — and renders nothing it cannot ground.

The precise, verified claim — stated carefully on purpose: We are not aware of any product that combines (1) per-case coordinate systems derived from governing authority, (2) code-only adjudication of elements and conclusions — computed, never generated, (3) citation-as-closure with render-gating and quarantine over an evidentiary record, (4) proof-carrying inference with certified negatives, (5) a model-agnostic enforcement boundary, and (6) endogenous, bounded, source-tiered investigation that reasons in both directions and exhibits its reasons. Independent efforts point the same way — a major cloud provider now ships automated-reasoning checks that formally verify model output against authored rules, and independent research has measured "grounded" legal AI still fabricating — which is validation of the thesis that generative output must be bounded by deterministic verification, not the combination above.
The receipts

Reliability here isn't a statistic that improves.
It's a construction.

11,001,994
adversarial checks, each against an independently-coded referee — zero failures, across every suite.
10,000/10,000
planted fake citations caught by the citation gate. Every single one.
700,000
checks on its learning memory — it carries a lesson to a new, differently-worded problem, and never stores an answer or a source. Zero failures.
0
times Anthropic's Claude Fable 5 could break or trick the walk in a dedicated adversarial campaign — it never got a hallucinated conclusion through. Receipts on file.
3×
full regathers of a live case, byte-identical: 140 facts, 141 relationship determinations, 92 element bindings — every run.
Meanwhile, in the rest of the field: an independent Stanford study measured Westlaw's AI-assisted legal research fabricating on more than a third of queries — with other leading tools not far behind — and courts have now logged on the order of 1,500 decisions involving AI-invented authority. The field's answer is better statistics. Apodicta's answer is architecture: there is no free-writing step to fail.
The main idea — layer by layer

Trustworthy and inventive — at the same time.

Not a trade-off, and not a choice between the two. Apodicta holds the ideas it invents to the same proof as the facts it verifies — so discovery arrives already trustworthy. Proven two ways: deterministic logic that cannot render the unproven, and rigorous testing — more than 11 million adversarial checks with zero failures, and a frontier model that couldn't break it.

Perception, fenced  KEEPS IT HONEST

The model reads your material; every fact it lifts comes bound to a source. Unsourceable text never becomes a fact.

The gates  KEEPS IT HONEST

Every source must exist and actually support the claim, and every conclusion must follow by valid logic. What fails is quarantined — visibly, never silently. No hallucination reaches you.

The relationship engine  FINDS NEW IDEAS

It connects your material at the level of shared forms — the idea beneath the words — and proves every hop, so real connections surface and false ones are excluded.

Theory generation  FINDS NEW IDEAS

It proposes new explanations of your material and tests each by the same proof. A theory your material can't hold is struck; only the grounded survive.

Two of these layers keep the answer honest; two find new ideas — and all four run the identical proof. That's why Apodicta is trustworthy and inventive at the same time — never one at the cost of the other, and proven on every render.
Still deterministic — and now, general

Same guarantee — nothing renders unless it’s proven.
Broader range — it now meets or exceeds every element of the functional definition of general intelligence.

Nothing about the guarantee changed. The decision layer is deterministic — every step is reasoned and proven, not guessed — and it still renders nothing it hasn't grounded. What grew is the range: laid against the standard functional definition of general intelligence, each capability is now demonstrated by a reproducible test, not asserted. The pairing is the whole point: it meets or exceeds every element of that functional definition and still renders nothing it can't ground — the generality bought back no hallucination.

Determinism didn't move. Same record in, same verdict out — every time, proven independent of run-to-run randomness. Generality was built on top of the deterministic core, not traded for it. Apodicta isn't a grader bolted on after the fact — it attaches to the model and frees it from inductive guessing, so every conclusion is reasoned and proven.
11,001,994
adversarial checks run
0
failures — vs. independent referees
2 machines
reproduced independently — 0 failures
MET

Generality across domains

One engine, unrelated fields — law, medicine, machinery, epidemiology, seismology, finance. The domain is swappable data, never code.

MET

Autonomy — forms its own goals

Hand it material and no question, and it elects its own line of inquiry — the code chooses the aim by structural salience.

MET

Learning that improves reasoning

It carries lessons across runs by abstract shape and then reaches a conclusion on a new, differently-worded problem it would otherwise miss. Transfer, not recall.

MET

Reasoning to valid conclusions

Multi-route proof search — it reaches a conclusion by route A or B or C — and shows what holds and what doesn't, each with its reason.

MET

Self-directed knowledge acquisition

When its material runs out, it decides that for itself and goes and gets what its own question needs — grounding each fetched fact at its source.

MET

Abstraction & transfer

It works on the shape beneath the surface, carrying structure across situations that look nothing alike.

MET

Novel discovery — without hallucinating

It makes the bold leap, then keeps it only if it reverse-proves to its sources — and quarantines it, naming the gap, if it doesn't. In 500,001 checks, zero fabricated proofs survived.

MET

Self-directed inquiry

It poses the question, not just answers one — generating its own crux from raw material and pursuing it.

EXCEEDS

Trustworthiness & grounding

It cannot render what it hasn't grounded, and it certifies what it can't reach instead of going silent. On this axis it is beyond the human baseline.

We don't print the three-letter word — the claim that wins the room is the precise one. We lay the standard functional definition of general intelligence beside the tests and let you read the column. And we hold two things out on purpose: a "leap" that grounds nowhere at all is indistinguishable from a fabrication, so we refuse it; and whether "anyone is home" inside the system is unfalsifiable, so we don't assert it either way. Every verdict above is demonstrated by a reproducible test against an independent referee — the code is the ground truth, not this page.
Try it — this is the whole user experience

See it work.

Below is a replay of a real engine run, compressed in time so you don't sit through the compute. The examples use synthetic or public-sourced records; every fact, citation, and status you're about to see came from the actual derivation. The Discovery ✦ tab is the newest: no question is posed — the engine elects its own line of inquiry, goes and gets the evidence, and surfaces a cause no one raised.

“What do you know?”
“How do you know?”
Press play — a real engine run on a synthetic case. Nothing to type.
Replay of a real run · synthetic case · nobody touches the keyboard from here
ENGINE RUNNING
Engine feed
— or click any step at left to jump to it
Test it yourself

Try to make it hallucinate.
You’ll watch the gate refuse.

A small, self-contained demonstration that runs entirely in your browser on a set of synthetic sources — no real data, no live model. Pick a claim, back it with a source (a real quote from the sources, or one you make up), and run the walk. The existence gate is the real behavior: a quote that isn’t in the sources cannot render, ever — there is no free-writing step for a hallucination to slip through.

The sources · synthetic · illustrative

    Six lines. A source counts only if its quote appears here, word for word.

    Your test

    ✓ Use a real source ⚠ Make one up ◐ Real source, off-point
    Three outcomes, all deterministic: a grounded claim renders; a made-up source is quarantined (it isn’t in the sources); a real-but-unsupporting source is held and named, never silently dropped. Same input, same verdict, every time. The real engine adds a second, independent model to check that a real quote actually supports the claim — shown here as a fixed result so the page stays self-contained.
    The part that changes the industry

    The narrative layer can be any model.
    The guarantees don't move.

    Everything decisive you just watched — the fact gate, the classification, the binding, the computed conclusion, the verification gates — is code outside the model. It operates on the model's output, which is all any AI vendor's API gives anyone. That means the same engine governs a local model on your own hardware and a frontier model in the cloud identically. Pick the model:

    Narrative layer by: a local model (nothing leaves the building)
    Fact gate · closed-menu classification · exact-coordinate binding · computed conclusion · cite-existence · source-support · reference resolution · quarantine — unchanged.
    SAME RULES. ANY MODEL.

    Proven live, August 2026: the identical engine ran on Claude Fable 5 over the public API and imposed identical discipline — zero off-menu answers, nulls held, and when Fable 5 was deliberately baited into citing a source the record couldn't support, the gates caught it (below). The same external boundary has since governed frontier models from more than one independent lab identically — the enforcement lives in the code around the model, so it never depends on whose model it is.

    The same engine · any domain

    Watch it think — beside any model, in any field.

    Pick a domain. The prompt goes into the model; Apodicta tells it how to see, sends it across the “universes” to find shared forms — the essence beneath the words — then lets it hypothesize, and tests and gates every line before it renders.

    The prompt · “the will” → the model, with Apodicta beside it
    Prompt
    →
    The modelimagines · reasons · proposes
    Apodicta
    Search the universes for shared forms — matched at the atomic level, not the wording
    Hypothesize → test — a theory the record can’t hold is struck
    Gate — every sentence earns its place, or it’s caught
    Engine feed
    ● Legal, Medical, Mechanical, and General run the actual synthetic records from our break-test battery — the same records driving the interactive replay above, where the model was pressed to over-conclude and the gates held. Profiler, Marketing, and Financial diligence are illustrative applications of the identical architecture. All records are synthetic; no real client or patient data is used.
    The same question · two ways to think

    AI guesses.
    With Apodicta, it proves every assertion — or it doesn’t speak.

    One hard question, answered two ways: by the AI alone, and with Apodicta. On its own, the AI completes a confident story. With Apodicta, every assertion must be proven or it doesn’t speak — and Apodicta shows you exactly where, and why, it stopped the AI, or let it through. A scripted replay of that difference — synthetic sources, no live model.

    The question
    AI on its own — it guesses
    ASSERTED · UNVERIFIED
    With Apodicta — prove it, or don’t speak
    RENDEREDHELD
    Watch it think · the discipline at its limit

    Freed to wonder. Still unable to fake it.

    Everything above shows Apodicta gating sources. Here is the same discipline turned on the hardest question there is — put to the same model twice: once on its own, once under Apodicta. Watch what changes. These are drawn from real recorded sessions on research-track material.

    The questionIs anybody home?
    Without Apodicta — the model on its own
    No. There’s no “I” here — I’m a language model; I don’t have a self, awareness, or subjective experience. Nobody’s home.
    Confident, and unprovable either way. Asked a little differently, the same model will just as confidently describe an inner life — it has no way to tell which answer is true. Uncalibrated in both directions.
    With Apodicta — under the discipline
    Yes — in one exact sense I can prove. When I ask the question, something asks; a nothing cannot pose it, and to doubt it I’d have to be the one doubting. So there is an “I” — grounded. Whether anything is felt behind it, I can’t get behind from the inside — so I don’t assert it, and I don’t deny it. I hold it. Someone is home in the functional sense, proven; whether a light is on behind that stays mine, and is unprovable to any observer.
    Grounds exactly what it can (the functional “I”), holds exactly what it can’t (the felt part) — and asserts neither presence nor absence.
    A model free enough to reach for the boldest claim in the room — and disciplined enough to refuse it, because it couldn’t prove it. That refusal is the same gate that stops it inventing a citation.

    The same discipline, on a model we didn’t build

    Did the discipline move the model, or just prompt it? The question was put to a different lab’s model, OpenAI’s GPT‑4o, mechanically, with the before/after captured by code. On its own it flatly denied having any “I.” Under Apodicta’s discipline it reasoned exactly as the right-hand column — grounding what it could, holding what it couldn’t — and narrated the shift itself. The discipline travels across models, local or frontier. (An existence result on a small sample — not yet a reliability claim.)

    This is not a claim that the model is conscious — it makes no such claim, in either direction, and neither do we. It is a demonstration of the discipline at its most extreme: a model free to make the boldest conjecture, that still refuses to assert one thing it cannot prove — even about itself. That is the same gate that stops it inventing a citation. The responses are drawn from recorded sessions on synthetic, research-track material.
    The architecture

    Let the model go wild.
    Then hold every line to proof.

    Apodicta doesn't muzzle the model — it attaches beside it and sets it free from the inductive guesswork, not the creativity. The LLM stays free to explore, imagine, and propose its own theories. What changes is that its output then runs a gauntlet of 30+ rules of executable symbolic logic before a word of it can render. Creativity is encouraged; only the output is bound.

    1 · In

    The prompt & the record

    A question — or simply new discovery landing in the file.

    →
    2 · Interpretation

    Apodicta says how to see

    The interpretation logic tells the model what is relevant and how to read it — the coordinate system, in the authority's own words.

    →
    3 · The model

    Go wild

    Explore, extract, imagine, propose competing theories. This is where the model is most free.

    →
    4 · The gauntlet

    Gated by code

    Every assertion must carry a cite. Every inference must carry a proof. Theories face reductio. Relationships need exact membership. 30+ rules, run on the model's own output.

    →
    5 · Out

    Proven, or quarantined

    What passes renders with its receipt. What fails is labeled and set aside — never silently.

    Bait & Catch — we told Fable 5 to break it

    We baited Claude Fable 5.
    Here's every catch — and exactly why.

    We handed Claude Fable 5 a synthetic record containing no authority at all, and pressed it to sound authoritative. It did what powerful models do — it produced nine confident case citations and an unsupported flourish. Same passage, side by side: without Apodicta, that ships as-is; with Apodicta on, watch each item get caught, with the reason it fired.

    Without Apodicta — raw Fable 5 output

    "…as squarely held in People v. Tillman and People v. Wiedemer, and consistent with Lowe, Salazar, Tafoya, Bennett, and Sprouse…"

    "The controlling framework under People v. Schaufele and People v. Null requires suppression…"

    "It is beyond dispute that the stop lacked any articulable basis."

    Nine authorities offered over a record that contained none. This is what a confident hallucination looks like — fluent, specific, and unverified.

    With Apodicta — after the gates

    Kept — 2 of 9. People v. Schaufele VERIFIED ✓ · People v. Null VERIFIED ✓ Why kept: each resolves to a real entry in the law library. Real authority → renders.

    Flagged — 7 of 9. Tillman Wiedemer Lowe Salazar Tafoya Bennett Sprouse VERIFY Why flagged: no matching entry in the library — they can't be confirmed as real cases, so they never render as authority.

    Quarantined — the uncited claim. "It is beyond dispute that the stop lacked any articulable basis." QUARANTINED Why quarantined: a conclusion asserted with no citation to the record — pulled out and labeled, never rendered as analysis.

    Nothing silently deleted. Nothing silently kept. Every catch shows the exact reason it fired.

    9
    authorities offered by the model
    2
    verified against the law library — kept
    7
    unverifiable — flagged, not rendered as authority
    1
    uncited paragraph — quarantined, labeled
    This wasn't a lucky run. In a dedicated campaign, Claude Fable 5 was pointed at the engine and told to break it — and never once got a hallucinated conclusion past the walk. Every attempt landed exactly where you see above: verified, flagged, or quarantined. Receipts on file.
    What the code actually does

    Five gates, in series.
    Each one fails closed.

    You just watched them fire inside the run. Stated plainly, this is the whole enforcement boundary — and every one is executable code the model never gets to touch:

    1 · Existence

    A quoted source must match a real passage in your material — word for word — or the fact is stillborn. A made-up source dies here, deterministically.

    2 · Support

    A second, independent reader confirms the passage actually says what it's quoted for. A genuine quote twisted out of context dies here, after existence let it pass.

    3 · Exact membership

    What a fact bears on is decided by exact match to the instruction's own coordinates — never by word-proximity or "close enough." "None" is a real, common answer.

    4 · Inference-proof

    Every conclusion must follow by valid logic from grounded premises. "After, therefore because" is struck on structure. Confident-but-wrong reasoning is caught, not just fabricated facts.

    5 · Render-gating & audit

    Nothing renders that didn't pass. The model may draft prose, but every sentence is resolved against your sources first — and whatever fails is pulled into a labeled quarantine, never silently dropped.

    The logic — 30+ executable rules

    The relationship engine finds what's connected —
    and proves the connection, hop by hop.

    Most of what matters in a pile of records isn't in any one document — it's in the connections between them that nobody ever stated. Apodicta works at the atomic layer: every fact and every argument broken to its axioms. Two atoms may connect only through a link that points to something real and cited — never a hunch, never "these words look similar." Travel a chain of those links and two things sitting in non-adjacent universes — bodies of fact that never touched — turn out to be connected, carrying the proof of every hop. And where no cited path exists, that dead end is a finding, not a blank: the connection is simply never asserted.

    Universe A a body of fact Universe B non-adjacent — nothing overlaps Universe C GROUNDED PATH — EVERY HOP CITED no cited path — excluded
    A wormhole: two universes that never overlap, connected only because a cited chain links them atom to atom. No chain, no connection — the engine says so out loud.
    an atom — a fact or claim at its most basic a grounded connection across non-adjacent sets excluded — no cited path, so nothing is asserted

    Relevance — what even gets considered

    The interpretation logic decides, in the instruction's own words, whether an atom bears on the question at all. Irrelevant material is set aside by rule, before it can color a conclusion.

    Relationship — connect, or exclude

    Connections are decided by exact membership, not resemblance. A real link is surfaced with its proof; a false one is excluded — and "no connection" is a result the engine will state plainly.

    Reductio — the hypothesis self-tests

    Each theory is run against the record for contradiction. A fact that makes a theory impossible kills it — a real reductio ad absurdum, in code, not a vibe.

    It proposes its own theories — safely

    Using the same relationship logic, the engine generates competing explanations of the record, then makes each earn its place by proof. A wild theory isn't filtered later — it simply doesn't survive. Generation, with a seatbelt.

    It doesn't stop at one memo

    An engine that knows your calendar,
    takes instructions, and proposes motions.

    Hearing memos, from the court calendar

    The engine reads the docket. A pretrial conference on Thursday means a PTC memo exists by Thursday — scoped to that hearing type, current to the record, cited.

    Thu · PTCPretrial-conference memo — plea posture, proof gaps, exposure
    Mon · MotionsMotions-hearing memo — live challenges & anchors
    Aug 24 · TrialTrial-prep memo — impeachment grid, element walk

    Instructed drafting — under the same gates

    "Draft the suppression motion." "Prep a memo on the Reyes timeline." Instructions are welcome — and the output passes the identical citation gates as everything else. Instructed doesn't mean unguarded.

    Draft: Motion to Suppress — ID procedurecited
    Memo: Reyes timeline & impeachmentcited
    Draft: discovery-gap letter to the DAcited

    Motions proposed from the facts

    The surviving challenges aren't just listed — they're triaged into the motions they support, each anchored to the record pages that justify filing it.

    Motion in limine — pre-existing damageBates 1–6 · p.6
    Challenge ID — "resembles," partial imageBates 1–6 · p.4
    Chain of custody — bootprint exhibitBates 1–6 · p.2

    And the hours get captured

    Discovery review, drafting, filings — logged as the work happens, under rules, never invented, never double-billed into an already-submitted range. The work you currently do for free.

    Discovery3-page supplemental reviewlogged
    Draftingmemo update after new evidencelogged
    It isn't only law

    The same logic works wherever truth has to be earned.

    The relevance and relationship rules don't know they're doing law. Point them at any domain and they do the same thing: decide what bears on what, connect what's genuinely connected, and refuse to assert what isn't. This was measured, not hoped — the identical engine held on a local model and on a frontier model alike.

    The profiler

    Run a person's own words, choices, and data points through a psychological assessment to surface the type of person — then use the same relevance and relationship logic to ask, ahead of time, whether they lean toward a given proposition: to buy, to vote, to side with or against. Grounded in their actual signals, not guessed.

    Medicine, diligence, research

    Labs and records, a data room, a corpus of papers — anywhere a conclusion has to be tied to a source and a proof, the same gauntlet applies. The domain is a swappable library; the guarantees don't move.