Category Definition
Architecture: Deterministic Compiler vs. Probabilistic AI
// WHY JUDGMENT ≠ GENERATION
The short answer
A probabilistic model such as ChatGPT generates the most plausible answer, so the same deck can get a different assessment each time and the reasoning cannot be audited. A deterministic compiler tests the deck's claims against fixed constraints and returns the same score for the same recorded variables, with a record of which ones. Summarization tells you what the deck says; judgment tells you whether it holds.
// input: series_b_memo.pdf + model.xlsx
run 1 · LLM summary "Growth appears strong; margins healthy."
run 2 · LLM summary "Some concerns on churn; overall viable."
// different answers, and no way to say which one the committee relied on
run 1 · askOdin Clarity 54 / 100 · §3.4 churn contradiction
run 2 · askOdin Clarity 54 / 100 · §3.4 churn contradiction
// scored from recorded variables; the record shows which, traced to the model cell
The greatest systemic risk in modern venture capital is conflating narrative generation with structural judgment.
Legacy AI tools (ChatGPT, Claude, and their respective wrappers) are probabilistic generation engines. They format pitch decks and summarize data rooms competently. LLMs optimize for persuasion — they applaud a well-written narrative, but they cannot evaluate mathematical business physics.
askOdin is a deterministic physics engine. We do not generate text; we compile logic.
The Doctrine
LLMs optimize for persuasion.
askOdin compiles for physics.
Summarization and Judgment Are Different Operations
Most failures of LLM-based diligence start from one assumption: that summarizing a deck and judging it are the same job. They are not.
Summarization condenses. Given a pitch deck, a language model writes a coherent account of what it says, and the summary is good if it represents the deck faithfully. Judgment interrogates. Given the same deck, a compiler returns what the deck claims, what the underlying constraints support, and where the two part company.
A summary tells the partner what is in the deck. Judgment tells the partner whether it holds. The first is useful. It does not substitute for the second.
Why LLMs Hallucinate on Capital-Allocation Work
A language model is built to produce the next plausible word. On well-documented topics, plausible is usually correct, because the training material is dense and consistent. In diligence, the two come apart, for three reasons.
The source material is adversarial. Founders write decks to persuade, not to disclose. The outcome data is thin. Most private investments never reveal what happened, so there is little ground truth to anchor on. The work is arithmetic. Whether a unit-economic claim holds depends on math the model narrates rather than computes.
So the model writes something that reads like analysis without doing the analysis. It is not broken. It is doing what it was built to do, in a domain where that is the wrong job.
What Each One Returns
| Dimension | Probabilistic LLM | Deterministic Compiler |
|---|---|---|
| Evaluation | Probabilistic LLM Predicts the most plausible next word. Arithmetic is narrated, not computed. | Deterministic Compiler A statically-typed Go engine computes the result outside the model. |
| Primary output | Probabilistic LLM A confident prose summary. | Deterministic Compiler A Clarity Score from 0 to 100 across five scored pillars and three audit checks. |
| Assumptions | Probabilistic LLM “Looks promising.” | Deterministic Compiler Brittle assumptions inventoried, each cited to the source text that asserted it. |
| Fatal contradictions | Probabilistic LLM “Some risks noted.” | Deterministic Compiler Flagged at the Critical tier, with the evidence on both sides. |
| Run it twice | Probabilistic LLM A different answer is possible each time. | Deterministic Compiler Same recorded variables, same score — checked from the record. |
| Record | Probabilistic LLM A chat transcript. | Deterministic Compiler A Defensible Audit Log anchored to SHA-256 fingerprints of the documents read. |
The askOdin Protocol Stack
U.S. PATENT PENDING 63/948,559The RUNE Protocol™ Architecture
Extraction is LLM. Evaluation is Go. Separation is the audit trail.
Ingest
File ParserUnstructured data (PDF, PPTX, DOCX) is parsed into structured text blocks.
Extract
Extraction onlyWe run LLMs strictly for extraction, pulling out typed claims (TAM, Unit Economics, Headcount) without letting the model evaluate them. The probabilistic layer reads. It does not judge.
Compile
Deterministic Go EngineThe extracted claims are routed entirely outside the neural network. A statically-typed Go engine mathematically evaluates the variables against the askOdin Judgment Graph™. This is where terminal physics violations — unit economics that mathematically cannot scale — are flagged.
Score
The Clarity Framework AggregatorThe engine outputs a verdict across five scored pillars and three audit checks, culminating in the Clarity Score™ (0–100).
// WHAT A MODEL CANNOT GUARANTEE
Three Operations an LLM Cannot Guarantee
Cross-document reconciliation
Comparing the deck against the financial model means reconciling their numbers, and language models do not do that reliably across long contexts. RAVEN Protocol™ (U.S. Prov. Patent No. 63/994,876) is built for this one job. The WeWork S-1 Terminal Audit shows the cross-document delta a single-document summary misses.
Constraint satisfaction
Whether a claim fits its constraints (TAM against population, penetration and price; lease liabilities against the revenue mix; the physics of the hardware) is a problem to solve, not to describe. A model predicts. The compiler solves.
Reproducibility
An LP review asks what the basis for the decision was. “We ran the deck through ChatGPT” is not an answer, because running it again may return something else. Reproducibility is a property of deterministic systems, and one that probabilistic ones lack by design.
// THE ARCHITECTURAL CHOICE
Use the Model for Triage. Use the Compiler for the Decision.
A general-purpose LLM is a reasonable way to summarize inbound material and decide what deserves a closer look. That is triage, and it does not need to be reproducible.
The decision a partner defends to an LP, a regulator or a board does. That needs a score that the same recorded variables always return, and a record of what was read and which variables were scored. The two stacks are complementary, not substitutes. Most funds will run both.
Competitive Physics
The LLM Commoditization Reality
When generic LLMs get faster and cheaper, the AI startups built as wrappers face an existential problem. For us, it just makes the extraction layer cheaper to run. Better LLMs are good for our margins, not bad for our moat.
Here is the difference. An LLM gives you inference. We give you a benchmark universe. The LLM can generate a verdict that sounds right; it cannot issue a score the same way twice, against the same standard, that an LP can audit two years from now. That is not a model problem. That is an architecture problem.
- Probabilistic LLM: inference, non-reproducible verdict
+ askOdin: deterministic compile against 110,000+ benchmarked scores
// benchmarked on public deal data
// same recorded variables → same Clarity Score
+ auditable by an LP two years from now
// DETERMINISTIC VS. PROBABILISTIC
Frequently Asked Questions
What is the difference between deterministic and probabilistic AI?
Probabilistic AI, such as a large language model, samples its answer from what is likely to come next, so the same question can return a different answer the next time. Deterministic AI computes its answer from fixed rules, so the same inputs return the same output every time. askOdin uses both, for different jobs: a model extracts claims from the documents, and a deterministic Go engine evaluates them, which is why the same inputs return the same Clarity Score.
Why does ChatGPT fail at pitch deck analysis?
It does not always get the verdict wrong. It gets it for reasons you cannot underwrite. In our Theranos backtest, ChatGPT-4o declined the deal, but because the narrative was vague, not because the numbers contradicted each other. A more fluent version of the same fraud would not trigger that objection. A generative model's objective is plausibility, so its assessment tracks how well the deck is written, and it can come out differently the next time you ask.
Why do LLMs hallucinate on unit economics?
Because they predict the next plausible token; they do not solve equations. Asked for a unit-economic conclusion, a model produces the most likely-sounding conclusion given the prompt, not the one the underlying numbers support. That is why askOdin uses a model only to extract claims from documents, and never to evaluate them.
What is deterministic AI for capital allocation?
An engine that compiles a deal's claims against constraints and returns reproducible findings. Given the same recorded variables under the same Framework version, askOdin's RUNE Protocol (U.S. Provisional Patent No. 63/948,559) returns the same Clarity Score, the same brittle-assumption inventory and the same Critical-tier findings. Reproducibility is what makes a decision auditable.
Can a generic LLM catch a fatal contradiction between the deck and the financial model?
Sometimes, but it cannot guarantee it. Catching one means reconciling the numbers across two documents and flagging the divergence, and a generative model tends to blend the two into one plausible figure instead. askOdin runs the same cross-document check the same way on every audit. It can only test what the documents contain: it audits reasoning, not truth.
Should an investment team stop using LLMs?
No. A general-purpose LLM is a reasonable triage tool for summarizing inbound material. It is not the tool for a decision a partner has to defend to an LP, a regulator or a board, because it produces no reproducible record. The two are complementary, not substitutes.
RUNE isn't the model.
It's the compiler.