askOdin — AI Judgment Infrastructure for Capital Allocation

askOdin · Verify

The Architecture of Objective Truth.

Large language models optimize for persuasion. askOdin compiles for physics. Diligence does not reward a fluent narrative; it rewards deterministic, repeatable execution. askOdin runs across four U.S. Provisional Patents, mathematically preventing hallucination and context-window contamination at compile-time.

U.S. PATENT APP. NOS. 63/948,559| 63/994,876| 64/011,252| 64/017,488
askodin · patent --status
$ askodin patent --status
PAT-001RUNE ········· 63/948,559
PAT-002RAVEN ········ 63/994,876
PAT-003NORN ········· 64/011,252
PAT-004JUDGE ········ 64/017,488
assert rev mkt p.4 C12 ≤1.0 1.4 ✕

RUNE Protocol™: The Domain-Specific Compiler.

U.S. Provisional Patent No. 63/948,559

Current AI extracts text. RUNE compiles it. The RUNE Protocol translates unstructured natural language into an executable, logic-validated dependency graph — anchoring every extracted variable to its source text with a persistent Brittleness Score. A claim is not a sentence to be summarized; it is a variable to be constrained.

U.S. PATENT PENDING 63/948,559

CLAIM 01

Compile-Time Error Detection

Identifies logical physics violations — e.g. market_share > 100% — before a single token of analysis is generated, not after.

CLAIM 02

Uncertainty Propagation

Mathematically cascades the semantic ambiguity of a source claim through every downstream calculation, so brittle assumptions cannot hide inside a confident-looking number.

UNSTRUCTURED INPUT

"We expect to capture 140% of the addressable market by FY27."

↓ rune compile
{
"var": "market_share",
"value": 1.40,
"constraint": "<= 1.0",
"brittleness": 0.73,
"status": "VIOLATION"
}

RAVEN Protocol™: Adversarial Triangulation.

U.S. Provisional Patent No. 63/994,876

A single context window will quietly smooth over contradictory data — that is what self-attention is built to do. RAVEN does the opposite. It performs cross-document triangulation across a heterogeneous data room and mathematically preserves the contradiction instead of resolving it away, denying the model any opportunity to hallucinate a reconciliation.

The architectural mechanics of RAVEN's triangulation engine are protected under U.S. Provisional Patent No. 63/994,876 and are not publicly disclosed.

CLAIM 01

Contradiction Preservation

When a deck and a model disagree, the contradiction is preserved and surfaced — never smoothed into a plausible-sounding reconciliation the way a single-context-window model would.

CLAIM 02

Cross-Document Provenance

Every reconciled figure is traced back to its origin across heterogeneous formats — PDF, spreadsheet, memo — so an allocator can audit exactly which two sources collided.

THREAD A · PDF
deck.pdf · p.7
Revenue
$5.0M
THREAD B · XLSX
model.xlsx · C12
Revenue
$1.2M
KILL SHOT Δ $3.8M unreconciled across documents

NORN Protocol™: Temporal Semantic Drift.

U.S. Provisional Patent No. 64/011,252

Companies rarely lie outright; their narratives drift. NORN isolates the divergence between narrative presentation and structural reality across chronological states — Q1 against Q3. When the story keeps improving while the structure keeps degrading, that gap has a name: Narrative Inflation. NORN measures it.

CLAIM 01

Latent Drift Calculation

Flags Narrative Inflation: the presentation gets louder ΔP ≥ 0 while the underlying structure quietly degrades ΔC < 0.

CLAIM 02

Retroactive Graph Weighting

Uses confirmed structural failures to adjust the relational decay weights of future deal-flow queries — the corpus learns from every resolved outcome.

SEMANTIC DRIFT · Q1→Q3
— Presentation— Clarity
Q1 Q2 Q3 DRIFT DETECTED
ΔPresentation +0.31 ΔClarity −0.44

JUDGE Protocol™: The Runtime Circuit Breaker.

U.S. Prov. Patent No. 64/017,488 | IPOS §34 National Security Clearance (Issued 2026-03-26)

The asymmetric immune system for generative AI. JUDGE sits at runtime: it intercepts probabilistic-hallucination payloads, isolates the hallucinated variables, and atomically hot-loads the active constraints — without altering the underlying neural network. The model keeps generating; JUDGE decides what is allowed to survive.

CLAIM 01

Rule Auto-Compiler

Evaluates intra-document semantic deltas and synthesizes new constraints on the fly — the engine writes its own guardrails as it reads.

CLAIM 02

Atomic Hot-Loading

Hot-loads new constraints across thousands of concurrent execution threads with zero downtime, without altering the underlying neural network.

judge · runtime.go HOT-LOAD
payload := llm.Hallucinated()
rule := compile(
"revenue.deck == revenue.xlsx"
)
mu.Lock()
rules["r_4821"] = rule
mu.Unlock()
✓ constraint live · 0ms downtime

// OBJECTION HANDLING

Technical FAQ

Isn't this just a ChatGPT wrapper with a nicer UI?

No. A wrapper passes your prompt to a language model and formats the reply. askOdin restricts the language model to non-generative extraction, then compiles the extracted variables through a deterministic Go engine that enforces business physics. The model is the CPU; askOdin’s deterministic compiler is the operating system.

Can’t you just set temperature to 0 to make an LLM deterministic?

Temperature 0 only forces the model to emit its single most-probable token — it makes the output stable, not the reasoning mathematical, and model-version drift, tokenizer changes, and floating-point effects still move the result. More fundamentally, the verdict never touches the model: a deterministic Go engine evaluates the extracted claims outside the neural network. Reproducibility is a property of the architecture, not a sampling flag — identical inputs return an identical Clarity Score and an identical hash.

How is this different from RAG (retrieval-augmented generation)?

RAG retrieves text into a probabilistic model that still generates the answer — the verdict remains a generation. askOdin retrieves nothing into the judgment path: the RUNE Protocol compiles claims into a logic graph and a deterministic engine evaluates them. Retrieval retrieves; we compile judgment.

Is the output reproducible — same input, same score, byte for byte?

Yes. Every audit is hash-anchored; re-running the same data room returns an identical Clarity Score and an identical SHA-256. The Defensible Audit Log makes any verdict reconstructible to the exact source cell or paragraph.

What exactly does the language model do versus the deterministic engine?

The language layer reads and extracts claims only — read-only and isolated. It never evaluates. A statically-typed Go engine performs every calculation and renders the verdict. The separation is the audit trail.

Are the patents granted or just provisional?

Four U.S. provisional patent applications are filed — RUNE (63/948,559), RAVEN (63/994,876), NORN (64/011,252), JUDGE (64/017,488) — and the JUDGE Protocol holds IPOS Section 34 National Security Clearance, issued 2026-03-26. Stated plainly: provisional, filed, and in the case of JUDGE, cleared.

Stop trusting probabilities. Deploy deterministic infrastructure.