Building the Chembricks epistemic discovery engine

Swipe to inspect · tap for full size

We did not want to build a clever chemistry demo and then mistake it for a general scientific method. We wanted to test the method itself: can LLM-assisted search become less like one long chat trajectory and more like a controlled research campaign?

That led to a simple but load-bearing hypothesis. If several research lineages can explore independently, mutate their ideas, recombine promising directions and learn from one another, can they make better discoveries than a single reasoning path? And can they do it without ever trusting the language model to judge whether its own claims are supported?

In this audit, “better” had a deliberately limited meaning. We asked whether branching explored more distinct core molecular structures, whether shared evidence recovered more relationships between features, and whether either produced a stronger top candidate at the same computational budget. Experimental usefulness remains a later test.

Two further requirements followed. First, the campaign needed a durable scientific memory. A hypothesis that fails a declared test is not wasted work. When the method, conditions and result are preserved, another branch can avoid repeating the same dead end. The system therefore had to grow a structured database of tested claims that passed, failed or remained inconclusive. A transcript of persuasive answers would not be enough.

Second, the architecture had to be more general than the chemistry task used to test it. The reusable pattern is a campaign, an executable claim, a domain-specific resolver and a recorded verdict. Chemistry is a demanding first test bed because molecules can be represented as executable artifacts and checked with models, cheminformatics and quantum calculations. Another scientific domain would need different artifacts and resolvers, but the trust boundary should remain.

We call the resulting system the epistemic discovery engine: a research loop designed around the origin, limits and traceability of every claim it uses.

A language model may propose hypotheses, mutate them and recombine them. But every candidate must become an executable artifact and pass through a named computational resolver before the engine may record that a declared criterion passed or failed. If no resolver can answer the question, or if the calculation fails, the answer is inconclusive. Plausibility never fills in the missing number, and the model is never trusted as the judge.

Why the usual agent loop was not enough

Many agent demos quietly couple proposal and judgment: the model invents an idea, calls a tool, interprets the output and then narrates whether it succeeded. That is convenient, but it leaves too much scientific authority in the narration. A retry can disappear. A timeout can become a negative result. A tool version can change. A malformed molecule can be replaced without consuming the budget. After enough steps, it becomes difficult to distinguish what was computed from what was merely said.

We split that loop in two. The search layer is allowed to be creative and probabilistic. It chooses strategies, proposes structures and decides where to explore. The evidence layer validates each candidate, runs an approved method and records what that method established. This makes the system honest about a computational result without confusing it with laboratory truth.

What we built: many lineages, one evidence layer

“Multiagent” here does not mean a panel of chatbots voting on the answer. It means several stateful research lineages exploring under one campaign contract. The contract fixes the objective, allowed tools, candidate and evaluation budgets, and the conditions a candidate must satisfy. Every branch shares the scientific boundary but can pursue a different strategy.

The campaign machinery is intentionally domain-general. It knows how to branch, spend a budget, submit a claim to an approved resolver, record the verdict and select the next direction. Chemistry enters through the candidate representation and the scientific tools behind the resolver. The same architecture could support another domain only when that domain supplies equally explicit artifacts, tests and limits.

Independent roots create diversity at the start. Mutation explores nearby variations. Crossover combines ideas that emerged in different lineages. A scientist can inject a new hypothesis without erasing what the system has already learned. The point is not to imitate a laboratory org chart; it is to keep genuinely different search histories alive long enough to discover something one trajectory might miss.

Swipe to inspect · tap for full size

The branch changes only after measurement

Each branch proposes a fixed number of candidates. Invalid structures still consume their slots; a bad answer never earns a free second chance. Valid candidates pass to a resolver, and only the resolver's result can determine what the branch keeps, mutates or offers for crossover. This turns evolution into a sequence of measured decisions rather than a chain of self-reinforcing stories.

The shared memory is a ledger, not a conversation

The branches do not exchange confidence or vote on what sounds right. They share completed records: the claim, the method, the result and the verdict. A supported relation can guide another branch. A failed relation can prevent repeated work. An inconclusive result can reveal where a better method is needed.

These verdicts accumulate in an append-only, tamper-evident claim ledger. It is the growing memory of what the campaign tested, not a transcript of what its agents believed. Positive and negative findings have the same status as evidence under their named conditions. Each branch can use that memory while retaining its own history and direction.

Suppose one branch proposes that adding a particular functional group will improve the target property. The resolver finds that the declared criterion is not met. Another branch can now avoid repeating the same substitution, challenge the conditions of the test or combine the failed idea with a different mechanism. The negative result changes the search instead of disappearing into a chat transcript.

The trust boundary: proposers generate, resolvers decide

The handoff between search and evidence is an executable claim: a specific candidate, a specific test, a named method and a fixed success criterion. “This molecule looks promising” can start a branch. “Under this named calculation, its electronic gap exceeds the declared threshold” can be computed.

A resolver computes the declared test. It may use a cheminformatics descriptor, a fast Chembricks model, an approximate quantum calculation, a higher-cost cross-check or reserved test data. Only that resolver writes one of three outcomes:

• Passed: the declared computational criterion was met.
• Failed: the declared criterion was not met.
• Inconclusive: the structure, computation or available evidence could not support a verdict.

Passed and failed always mean under the named method and recorded conditions. A timeout is not a failed molecule. A malformed response is not evidence. The engine stops at inconclusive rather than manufacturing an answer.

Swipe to inspect · tap for full size

What a real campaign feels like

A diagram can make an architecture look cleaner than an actual run. In practice, the engine moves through two connected but distinct rhythms: a broad search that creates and recombines candidates, and a promotion path that asks stronger scientific methods to examine only the candidates that earn the extra cost.

Then we tested whether the architecture changed discovery

Building the machinery was not enough. We wanted to know whether multiple lineages actually found more than one long reasoning path. We also wanted to know whether shared evidence improved anything beyond the story the agents told about themselves.

We wrote the comparisons before the reruns, fixed equal search budgets, kept every failed candidate in the count and repeated the campaign from new random starting points. The central result is easier to state:

The engine searched more broadly, but it did not produce a better top candidate.

The independent branches consistently explored a wider range of molecular structures than one search path. Shared evidence also changed what the campaign noticed: it became better at finding combinations of features that matter together, while paying less attention to simpler effects considered in isolation.

Those gains came with an important limit. Shared memory did not improve the best candidate score, and a classical optimizer remained better at driving a single numerical objective to its highest point. The agentic layer should therefore complement specialized optimizers, not replace them. Its role is to diversify hypotheses, preserve why a branch changed direction and decide which candidates deserve stronger evidence.

This is the kind of negative result we wanted the architecture to surface. A system that only reports its wins is not a discovery engine. A system that can reveal where branching helps, where memory merely reallocates attention and where a simpler method remains stronger is beginning to behave like a controlled research instrument.

Why this matters for a discovery team

Fast prediction alone does not decide where to search next. A discovery team may evaluate thousands of candidates and still lose the reasoning behind promising and unpromising directions. The epistemic engine preserves that history, explores several strategies at once and shows why each surviving candidate earned further attention.

This is how broader search becomes useful in practice. It does not automatically create a better molecule. It gives scientists a larger, structured set of testable options and helps reserve expensive computation or laboratory work for a smaller evidence-backed group.

The bottleneck moved from prediction to reasoning

This orchestration layer sits above the real foundation of Chembricks: proprietary quantum-chemistry data and the fast cmbx_ models trained on it. Those models are the primary moat. The epistemic engine is an additional capability that decides how to use predictions, other scientific methods and human direction in a traceable campaign.

That distinction changes the system design. Chembricks predictions return so quickly that molecular scoring is no longer the practical bottleneck in a broad campaign. The limiting resource becomes the language model's proposal, optional reasoning and retry time.

The answer is not to make every step “more intelligent.” It is to spend reasoning where it can alter a decision: inexpensive proposers for breadth, stronger reasoning for a small number of consequential choices, and physics-based calculations only for promoted candidates.

Swipe to inspect · tap for full size

What we built, and what we did not

The July audit leaves us with a rigorous, unusually auditable computational-discovery engine. It can run multiple research lineages, turn their proposals into executable claims, assign verdicts through named computation, keep failed attempts visible and accumulate a grounded claim ledger. It produced repeated gains in search breadth and recovery of feature interactions.

The campaign pattern is designed to span scientific domains, but the evidence in this article is chemistry-specific. Generality is an architectural claim to test next, not a result we can declare from one domain.

It is not a universally state-of-the-art autonomous scientist. It did not beat a classical optimizer at finding the best-scoring candidate. It has not yet produced a discovery validated by an independent high-level calculation and a wet-lab experiment.

For Chembricks, that is the right shape of the result. Our data and models make high-quality molecular prediction fast. The epistemic engine adds a way to search over those predictions without confusing eloquence for evidence. Scientists remain responsible for the question, the acceptable methods and the final experimental interpretation.

The next milestone is deliberately outside the system: a prospectively declared campaign whose leading candidates survive independent high-level computation and wet-lab measurement. This layer earns trust by making each computational claim inspectable and each uncertainty impossible to hide. It does not earn trust by claiming to replace scientists.

Computational screening and simulation support decisions. They do not replace experimental, safety or regulatory validation.

The Chembricks team