Stable routine data
Dynamic belief revision
Proposes new regimes
Blocks prompt injections
Catches spoofed claims

HUME

A deterministic, rule-based scientific belief-revision platform for the CORTEX BioSciences GROUND TRUTH challenge with no neural networks, no network calls, so it cannot time out, crash, or be talked into anything.

Inspiration

When looking at the GROUND TRUTH challenge, we noticed a major flaw in how everyone approaches scientific data parsing: throwing Large Language Models at the problem. The issue? LLMs can be talked into things. They hallucinate, they fall for prompt injections, and they struggle with strict determinism.

We wanted to build something fundamentally different. We were inspired by a single, unbreakable principle: provenance sets magnitude, the body text only classifies, and the two channels never cross. We wanted to prove that you could build an impenetrable, mathematically sound ingest system where everything resolves strictly from a read-only view and domain declarations, eliminating the need for a stochastic black box.

What it does

HUME reads scientific claims and safely maps them onto a trusted knowledge graph. But instead of trusting the text to dictate the importance of a claim, it uses a strict structural firewall.

The pipeline flows strictly in one direction: firewall → strength → parse → OOD → decision → magnitude.

Classification: The system parses the text only to determine which states are changing and in what direction. Out-of-distribution (OOD) data is flagged safely—for example, a potency-preserving jump is labelled a lateral_somatic_conversion, ensuring flagging is never just a lazy catch-all.
Log-odds accumulation: It takes structured provenance (how many groups, replications) and feeds it into a Bayesian log-odds engine. Because it's prior-aware, the same evidence will swing a contested 0.55 claim wildly, but barely nudge a near-certain 0.97 claim.
Quarantine: Single-source contradictions aren't blindly trusted; they are placed in a hold_pending state until independent corroboration arrives.

How we built it

We built HUME entirely as a deterministic, neurosymbolic platform, but running purely in rules-mode for perception.

We split the logic strictly at a seam defined by extract(body, view) -> EvidenceFrame. A build-failing test guarantees nothing downstream ever reads the raw text.

For the decision core, we bypassed a massive Bayesian net for a highly tuned, pooled likelihood ratio equation that naturally handles the compression and bounds we need:

$$ S = (0.65 \cdot \text{groups} + 0.35 \cdot \text{replications}) \cdot \text{directness} \cdot \text{effect_strength} \in [0,1] $$

$$ \operatorname{logit}(\text{posterior}) = \operatorname{logit}(\text{prior}) \mp 2.8 \cdot S $$

Because the math engine operates purely in log-odds, noise collapses to a no_op and the values never exceed the API's 3.0 cap.

Challenges we ran into

Scientific text is incredibly messy, and extracting direction and event scope deterministically was our biggest hurdle. We had to build NegEx/ConText-style scoping per clause with an "asserted-wins" rule.

Filtering out noise was brutal. We had to design the parser to correctly void negations ("did not revert"), modality ("if cells could..."), and static predications ("is more potent than") so they wouldn't register as actual state changes. Furthermore, inferring direction couldn't rely on simple word order. We tied it directly to the graph's own laws (e.g., transitions don't increase potency), meaning a forward progression required positive, explicit evidence to override the system's defaults.

Accomplishments that we're proud of

We are incredibly proud of our firewall. It is structural, not just a filter. Because no code path leads from body text to a payload value, injections and distractor poisoning are mathematically impossible.

We actually handed the system over to an independent red team. They threw about 90 different attacks at it—embedded directives, zero-width characters, letter-spacing tricks, and scientific override injections. They produced zero body-only mutations. Every single attack harmlessly degraded to a no_op.

What we learned

We learned that skepticism is actually security work, not just calibration. By forcing adversary-authored text into a narrow, typed, auditable interface, you rob it of its power. We discovered that independence dominates as the least-gameable signal in scientific literature. A fabricated false alarm is much easier to catch because of its thin provenance, rather than trying to recognize it from training data.

What's next for HUME

We know the exact ceiling of our rule-based lexical extraction. A sufficiently oblique negation or a source named in a bizarre, non-from phrase can still slip through (we actually keep one of these deliberately visible as an XFAIL in our tests).

Because our extraction logic is neatly isolated behind a single seam that emits a typed frame, the obvious next step is exploring how a small, localized neural extractor could be a clean drop-in replacement for the perception layer. We want to lift that lexical ceiling without ever compromising the deterministic firewall and probabilistic update engine downstream.