Why I'm building Talaria Scientific

We're building Talaria Scientific to accelerate computational science research. Talaria is a multi-agent, multi-foundation-model harness: a researcher directs it, and it runs the undifferentiated machinery of computational science validation (the coding, the environment building, the HPC runs, the record-keeping) that currently gets done manually. Below I'll explain what that means, why I'm doing it, and what impact I hope it has.

To learn more about how Distributional became Talaria Scientific check out this post.

The bottleneck was never the ideas

Every computational scientist I know carries around more hypotheses than they will ever get to test. The reviewer suggestion that got explained away instead of implemented. The seminar question that ended with "that's an interesting idea." The paper that raised a "what if?" in the margin. The shower thought that would take a month of setup to check.

Ideas pile up because robustly validating each one is tedious: the data that needs wrangling, the environments that won't build, the baselines that need reimplementing because the original code no longer compiles, the sweeps that die overnight, the checking and rechecking of logs that separates a real effect from a lucky one.

Even with all that, the validation is only half the burden. You also need to keep track of everything: which variants ran, what changed between them, where the project stood when the other project interrupted it, how to reproduce it all now (and later).

Ideas are what moves science forward, but validation is expensive and time consuming, and so validation bottlenecks the science. The pace should be set by the ideas.

Twenty years of the same problem

I've spent my entire career on different versions of discovering and trying to accelerate through bottlenecks in this process. In undergrad and grad school the same problem kept surfacing in every field I touched, from metagenomic assembly at the national labs to quantum mechanics at the Max Planck Institute: whatever the science was, the final step was always parameter tuning. We jokingly called the process "grad student descent": the least tenured person in the group, turning knobs in a high dimensional space by hand to try to get a better result. It burned expert time, it burned expensive compute, and the results were not even good: hand tuning stalls in local optima and brute force aliases over better configurations entirely. Making that step efficient became central to my PhD thesis, using Bayesian optimization to accelerate the tuning.

At Yelp I found the same tuning problem waiting in ads, search, and recommender systems, so I open-sourced my thesis as MOE, the Metric Optimization Engine (github.com/Yelp/MOE). It quickly garnered 1000+ GitHub stars (in 2014!) and spurred dozens of talks around the Bay, showing the problem was pervasive across industry. I turned it into my first startup, SigOpt, where we spent seven years running optimization as a service for demanding modeling teams in trading, tech, and research for everything from hyperparameter tuning to materials design and more. That was the first pillar: making the models better through optimization.

Intel acquired SigOpt in 2020, and I became VP of AI and HPC for Supercomputing, ensuring applications actually performed on the deca-megawatt machines headed to national labs. That was the second pillar: making AI and scientific code practical, working at real scale. It was there that a different problem surfaced. The models had grown powerful, and with power came complexity: non-determinism (the same question could return different answers), non-stationarity (behavior drifted as the weights/code evolved), and chaos (small input changes produced large output changes). Optimization could help you tune a model, but nothing in the stack told you whether you could trust what came out, or if you were just overfitting to some metric or eval. I had spent 15+ years building evals and ways to optimize them efficiently, but never dove into how you can trust them. So in 2023 I founded Distributional to build the third pillar: testing and analytics to make AI systems trustworthy and understandable.

Better models, scalable systems, trustworthy results: you need all three to do great science, and the work demands them together. I worked on the three pillars sequentially and am finally putting them together. Talaria Scientific is that synthesis: everything I've built, aimed back at the problems I have been trying to solve for the last two decades. And the target isn't science in the abstract. It's empowering the world's experts to go further, faster. It takes the grunt work humans are bad at (high-dimensional optimization, large-scale sysadmin, keeping track of everything) into the harness, on the record and under their control, and leaves the work only they can do, the ideas, fully in their hands.

What changed, and what didn't

Over the last three years, agentic coding changed what a strong software engineer can do in a week. The engineers getting the most out of these tools were already excellent: but now they direct agents, review the output, and ensure the architecture and systems align with their vision and taste.

Computational scientists do work with the same shape (code, data, infrastructure, experiments, validation), but their tooling sits roughly where software tooling was three years ago. Most are using AI for pieces of the process: asking a chat app instead of Stack Overflow, pasting snippets back and forth, cobbling it together as they go. There is a large gap between that and directing long-running agentic loops that build and validate entire swaths of the work, and software engineering has already demonstrated that the real acceleration happens when the tool understands the job.

The catch is that the job is different. Doing science is different from doing software engineering. Good unit test coverage is fundamentally different from making sure you don't violate physics. Shipping an app you can iterate on next sprint is fundamentally different from publishing a result that claims some truth about the universe and needs to be defensible forever. An agile board of tickets and pull requests is fundamentally different from scientific exploration and hypothesis testing. A general coding agent understands none of that, and the model companies are incentivized to go after the larger market: their agents are trained and RL-tuned on software engineering processes, apps, and code, not on the computational science process. To truly transform the process you need a tool built for the job.

We still make scientists grind their own mirrors

For a long stretch of astronomy's history, being a great observer meant being a great instrument maker first. William Herschel cast and polished his own speculum mirrors, sometimes sixteen hours at a stretch without taking his hands off the metal, because a telescope good enough for his questions wasn't something you could buy. The telescope was the bottleneck, so telescope craft was the job.

This is roughly how computational science is done today. A researcher's week goes to data wrangling, sysadmin, plotting, reimplementing baselines, and manually validating results. What remains, with what little time left, is the actual science: the smallest slice of the week by volume, and the only part that they alone can do. Science doesn't need to be slow; it has just always been bottlenecked by the tooling available. When mirrors became something you could buy, observation accelerated. When computers became something every lab could have, simulation accelerated. Agentic AI is the next accelerator, and right now scientists are still grinding it by hand.

Muscle and memory

We are building augmentation for the process, not automation of the scientist; a mech suit, not an android. A mech suit is amplification you wear, an android is a replacement you send off to act in your place. Herschel's telescope sat firmly on the suit side of that line by augmenting his eyes: it multiplied his power to see and never chose where to point itself. A mech suit takes the mechanical work off you, faster and better than doing it alone or delegating it to the most junior person in your lab, while every decision about where to walk stays yours. In software, scaffolding like this (the tools, memory, and checks wrapped around the models doing mechanical work) is called a harness, the application layer that sits on top of the foundational model substrate. The oldest version of the idea is why we chose the name: Talaria are the winged sandals of Hermes, which allowed the wearer to travel at the speed of thought. We aim to build tools to let researchers do computational science at the speed of thought.

This muscle of the suit removes the validation schlep, everything that sits between an idea and a result you can trust while adding no science of its own. It's the data wrangling, the environment setup, the baseline reproduction, the parameter sweeps, the manual results checking, plus the bookkeeping that shadows all of it. It is still trustworthy, valid, and reproducible science, but now you don't need to manually perform every step. The grind around the thinking, not the thinking.

A system of record is the suit's memory: every idea, run, result, and decision, kept with its provenance, whether or not it worked out. The lab notebook, inverted: a record the work keeps of itself instead of one the scientist has to remember to keep. It is what lets you put a project down in May and pick it up in September exactly where you left off; what lets a collaborator, a student, or a reviewer walk your actual search instead of your recollection of it; and what makes the trail from claim back to code, configuration, and environment reproducible instead of reconstructible.

The top panel is how computational science is traditionally done: one idea at a time crosses a wide band of schlep by hand, toward a result that arrives and, after enough manual steps and undocumented tweaks, is not even always a result you can trust. The bottom panel is the same span with Talaria: the undifferentiated work runs inside the harness below the dashed boundary, the human lane runs unbroken from idea to a trusted and reproducible result, and the loop from result back to the next idea tightens. That last part compounds: a faster loop doesn't just move one idea through sooner, it spins the whole flywheel faster. The dashed boundary is where the rest of this piece lives: what belongs below it, and why.

The mech suit

In software engineering there is a concept of a "10x engineer," someone who can do the work at the level of 10 other median engineers; these people are becoming "100x engineers" with agentic coding. The goal of Talaria Scientific is simple: take the 10x computational scientist and make them 100x. The gains land exactly where the tooling gap is biggest: the world-class researcher whose domain expertise no model has, and whose week still goes to work no scientist should be doing by hand. This also empowers everyone in the lab to put on the mech suit and explore their ideas, instead of spending years as the hands the work gets delegated to.

I believe that this can't be solved with a completely autonomous scientist, the version where you just point an agent at a problem and come back to perfect results. I believe we are a long way from just writing /goal solve stable fusion containment and then heading out for drinks. That dream is aimed at the wrong target, for two reasons.

The first is that novel research is out-of-distribution by design. A model trained on the world as documented is strongest where the world is well documented, and a discovery is precisely the place where it isn't. General capability keeps expanding over what's documented, but the interesting research keeps living past its edge, there will always be a frontier, by construction (Surfing the Frontier Wave that rests between The Bitter Lesson and No Free Lunch). So the scientist pushes past the edge of the known, and the machine fills in behind: running the validations, holding the provenance, keeping the record honest. The human stays on ideas and taste. The machine takes the schlep.

A boundary follows from this, and we hold it deliberately (it's the dashed line in the figure above). Mechanical work within an agreed budget usually benefits from just running: environment setups, sweeps, baseline reproductions, plots. Anything that smells like a scientific judgment gets proposed to the user, never assumed. No absolutes on either side: the boundary is a dial the scientist owns, not a law of the product.

In practice this helps in two ways. The first is cranking the machine: the suit runs the validation work in parallel, within budget, while you think and ingest results. The second is a better machine to crank: the system of record underneath the work that makes sure you can trust your results.

Optimizing for truth, not for an eval

Train an agent to optimize an eval with nothing pinning down the search or the reporting, and you have built a p-hacking engine, a perfect overfitting benchmaxxer. I saw this time and time again during SigOpt when we helped thousands of experts optimize their systems worldwide, only to realize at the end that they were aiming for the wrong thing. "Publishable" and "true" are different objectives, and an optimizer pointed at the wrong one will find exactly the results that separate them: the spurious findings.

So the harness optimizes for correctness, reproducibility, and truth, and "passes review" stays downstream, never the target. The integrity is structural, not aspirational. Results face adversarial review from agentic reviewers rewarded for killing a pet hypothesis rather than confirming it. And the full search gets recorded, not just the winners, because "we tried 50 things and report the best one" is the campaign-level version of p-hacking that no per-experiment rule catches (just like the famous xkcd).

The component that holds all of this is the system of record, and it was built in an opinionated way: a reference graph at the top (the literature you build on, linked so every claim traces to its source), a triad of hypothesis, results, and findings graphs growing beneath it (what you're asking, what actually ran, and what you now believe, with every result answering a hypothesis and every finding carrying its evidence), and a concept graph overshadowing all of them (the living map of definitions the other graphs share). Each of those structural choices exists to kill a specific way results go wrong, from orphan numbers to reruns that are reenactments instead of reproductions. You can read about the full anatomy and decisions made choice by choice here.

Rigor that blocks serendipity would be its own failure though. Science often advances by stumbling into things. So the design gates the strength of claims, never the existence of discoveries: nothing real gets blocked, it gets labeled honestly until it earns its confirmation. If a tool makes it easier to fool yourself, it makes science slower, not faster, whatever the throughput numbers say. But the harness allows for full, untethered exploration and lets you self-heal your system of record as you go, so when you are done you can trust every result you plan to publish (and can reproduce it exactly).

Where this is headed

Talaria is built for the people doing science in silico: the computational physicists, applied mathematicians, and simulation-driven engineers whose experiments run on solvers and clusters rather than in physical labs. The work that used to dominate supercomputer usage before LLMs. We are starting physics-first on purpose, because that is where the guardrails are strongest: physical invariants, convergence checks, and validated solvers give the harness something rigorous to hold the models against. And the reach is bigger than a tooling niche: better computational science methods push forward materials, aerospace, energy, and the world models behind robotics and autonomy. Each of those fields moves further, faster with better computational science research, and increasing the pace of that research is exactly what the harness is for.

Talaria is in private beta with a small group of computational scientists, starting where my own research lives: PDEs, optimization, and the compute-heavy corners of applied math. The product will be open source by NeurIPS 2026 and always free for open scientific work. How we're building it, and why in the open, gets its own post soon. If validation schlep is what slows your research down, or you just want to watch this get built, get in touch at talariasci.com.

The ideas were never the scarce part. Every computational scientist is carrying a backlog of them: the reviewer's suggestion, the seminar question, the what-if in the margin. Too many of those die of tedium rather than of being wrong. The bottleneck in computational science was never the ideas. If we do this right, it won't be the validation much longer, either.

If you are working on anything this touches (physics models, optimization, world models for robotics and autonomy, materials, aerospace, or anything fluids related), we want to hear from you. Reach out if you want to work with us.