# Talaria Scientific: Full Site Corpus This file concatenates every page on https://talariasci.com as plain markdown for one-shot LLM ingestion. Built automatically at deploy time. Per-page sources are at https://talariasci.com/index.md and `https://talariasci.com/blog/.md`. ================================================================ # Talaria Scientific > A multi-agent harness for computational science that turns a 10x researcher into a 100x researcher, with the scientist in the loop and HPC as the guardrail. We're building a multi-agent harness for computational science, tooling that turns a 10x researcher into a 100x researcher the way agentic coding did for software engineers over the last 3 years. The slow, expensive part of research is undifferentiated work in data wrangling, sysadmin, and validation. We make that part fast, with the scientist in the loop and HPC as the guardrail. It is a mech suit for the researcher, not an auto-scientist that replaces you. We believe research tooling should be open, and that integrity belongs in the design, not bolted on after. The product will be open source and we are building in the open: learn more on [our blog](https://talariasci.com/blog). ## Get involved Talaria is in **private beta** with a small group of researchers. [Request access](https://talariasci.com/signup) if you run computational experiments (PDEs, optimization, anything that validates on a single GPU) and want in. ## The manifesto [Why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria): validation, not ideas, bottlenecks computational science. Talaria is a multi-agent harness that takes the schlep (the coding, the environments, the HPC runs, the record-keeping) while the scientist keeps the science. The full blog lives at https://talariasci.com/blog. A new product from [Distributional](https://distributional.com), built by [Scott Clark](https://scottclark.io): creator of MOE (the first production Bayesian-optimization OSS), founder of SigOpt (acquired by Intel), former Intel VP & GM of AI and HPC Supercomputing. ## Links - [GitHub](https://github.com/talariasci) - [Hugging Face](https://huggingface.co/talariasci) - [X](https://x.com/talariasci) - [PyPI](https://pypi.org/project/talariasci/) - [npm](https://www.npmjs.com/package/talariasci) - [YouTube](https://www.youtube.com/@talariasci) - [LinkedIn](https://www.linkedin.com/company/talariasci) --- Source: https://talariasci.com/ ================================================================ # About: Talaria Scientific > Who is building Talaria Scientific and why: the founder's background, the Distributional lineage, and the thesis. I'm [Scott Clark](https://scottclark.io). I've spent my career building optimization and AI tools for experts [building on the frontier](https://talariasci.com/blog/no-free-lunch-bitter-lesson) as a founder of SigOpt, VP of AI and HPC at Intel, and founder of [Distributional](https://distributional.com). Talaria Scientific is [Distributional's next chapter](https://distributional.com/blog/distributional-is-now-talaria). We can now meaningfully accelerate science with AI. And that is what we aim to do with a multi-agent, multi-FM harness for computational science research acceleration. ## The manifesto [Why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria): validation, not ideas, bottlenecks computational science. Talaria is a multi-agent harness that takes the schlep (the coding, the environments, the HPC runs, the record-keeping) while the scientist keeps the science. --- Source: https://talariasci.com/about ================================================================ # Request access: Talaria Scientific > Request access to the Talaria Scientific private beta. Talaria is in **private beta** with a small group of researchers. Talaria is for researchers who run computational experiments: PDEs, optimization, anything that validates on a single GPU. [Request access](https://docs.google.com/forms/d/e/1FAIpQLSdmgoEwtl7zgeoRjpD3au_Sz2eoK44HUgkW6LZV0aBpR4g2IA/viewform) New here? Start with [the manifesto](https://talariasci.com/blog/why-im-building-talaria). --- Source: https://talariasci.com/signup ================================================================ # Press kit: Talaria Scientific > Headshots, logos, and bios for Scott Clark and Talaria Scientific, cleared for use in talks, panels, podcasts, and press coverage. This page is the one place to get current material for introducing [Scott Clark](https://scottclark.io) or Talaria Scientific: headshots, logos, and bios in three lengths, ready for an event page, a program, a podcast description, or an article. Everything here is for use as-is when you are describing Scott or Talaria Scientific: take bios from this page rather than from an older copy, use the photos unaltered, and use the logo files unchanged. Last updated 2026-09-14. Need something that is not here? [Reach Scott directly](https://scottclark.io). Plain-text bios: https://talariasci.com/press/scott-clark-bios.txt On the page: [Headshots](https://talariasci.com/press#headshots) · [Bios](https://talariasci.com/press#bios) · [About Talaria Scientific](https://talariasci.com/press#about) · [Logos](https://talariasci.com/press#logos) ## Scott Clark - **Name:** Scott Clark, Ph.D. - **Title:** CEO, Distributional - **Introduce as:** Scott Clark, co-founder and CEO of Distributional, building Talaria Scientific. (Talaria: "tuh-LAIR-ee-uh", rhymes with malaria.) - **Talks:** [scottclark.io/talks](https://scottclark.io/talks) ### Bios Third person, ready to paste. **One line (19 words).** Scott Clark is the co-founder and CEO of Distributional, building Talaria Scientific, a multi-agent harness for computational science research. **Short (79 words).** Scott Clark is the co-founder and CEO of Distributional, building Talaria Scientific, a multi-agent harness for computational science research. He was previously co-founder and CEO of SigOpt, a VC-backed Bayesian optimization startup acquired by Intel in 2020, where he then served as VP and GM of AI and HPC supercomputing through 2023. He holds a PhD in applied mathematics and an MS in computer science from Cornell University, where he was a Department of Energy Computational Science Graduate Fellow. **Long (143 words).** Scott Clark is the co-founder and CEO of Distributional, building Talaria Scientific, a multi-agent harness for computational science research that turns a 10x researcher into a 100x researcher, with the scientist in the loop and HPC as the guardrail. He previously co-founded and led SigOpt, a Bayesian optimization company acquired by Intel in 2020, and then served as Intel's VP and GM of AI and HPC Supercomputing. At Yelp he co-created MOE, the first production open-source Bayesian optimization engine. Scott holds a PhD in applied mathematics and an MS in computer science from Cornell University, where he was a Department of Energy Computational Science Graduate Fellow, and three bachelor's degrees, in mathematics, physics, and computational physics, from Oregon State University. He was named to the Forbes 30 Under 30 list in enterprise technology in 2016 and lives in the San Francisco Bay Area. ### Profiles - Website: [scottclark.io](https://scottclark.io) - LinkedIn: [linkedin.com/in/sc932](https://www.linkedin.com/in/sc932) - X: [@DrScottClark](https://twitter.com/DrScottClark) - Google Scholar: [profile](https://scholar.google.com/citations?user=mwWbhAUAAAAJ) - GitHub: [sc932](https://github.com/sc932) - ORCID: [0009-0007-0478-7129](https://orcid.org/0009-0007-0478-7129) ## Headshots **Square** - JPG 2400x2400: https://talariasci.com/press/scott-clark-headshot-1-square-2400.jpg - WEBP 2400x2400: https://talariasci.com/press/scott-clark-headshot-1-square-2400.webp - JPG 1200x1200: https://talariasci.com/press/scott-clark-headshot-1-square-1200.jpg - WEBP 1200x1200: https://talariasci.com/press/scott-clark-headshot-1-square-1200.webp **Portrait (4:5)** - JPG 2400x3000: https://talariasci.com/press/scott-clark-headshot-1-portrait-2400x3000.jpg - WEBP 2400x3000: https://talariasci.com/press/scott-clark-headshot-1-portrait-2400x3000.webp - JPG 1200x1500: https://talariasci.com/press/scott-clark-headshot-1-portrait-1200x1500.jpg - WEBP 1200x1500: https://talariasci.com/press/scott-clark-headshot-1-portrait-1200x1500.webp **Square** - JPG 2400x2400: https://talariasci.com/press/scott-clark-headshot-2-square-2400.jpg - WEBP 2400x2400: https://talariasci.com/press/scott-clark-headshot-2-square-2400.webp - JPG 1200x1200: https://talariasci.com/press/scott-clark-headshot-2-square-1200.jpg - WEBP 1200x1200: https://talariasci.com/press/scott-clark-headshot-2-square-1200.webp **Portrait (4:5)** - JPG 2400x3000: https://talariasci.com/press/scott-clark-headshot-2-portrait-2400x3000.jpg - WEBP 2400x3000: https://talariasci.com/press/scott-clark-headshot-2-portrait-2400x3000.webp - JPG 1200x1500: https://talariasci.com/press/scott-clark-headshot-2-portrait-1200x1500.jpg - WEBP 1200x1500: https://talariasci.com/press/scott-clark-headshot-2-portrait-1200x1500.webp ## About Talaria Scientific **Short (39 words).** Talaria Scientific is a multi-agent harness for computational science that turns a 10x researcher into a 100x researcher, with the scientist in the loop and HPC as the guardrail. It is built by Distributional and is in private beta. **Long (123 words).** Talaria Scientific is a multi-agent harness for computational science: tooling that turns a 10x researcher into a 100x researcher, the way agentic coding did for software engineers. The slow, expensive part of research is undifferentiated work in data wrangling, sysadmin, and validation. Talaria makes that part fast, with the scientist in the loop and HPC as the guardrail. It is a mech suit for the researcher, not an auto-scientist that replaces the scientist: the harness runs the experiments, records them, and keeps the researcher in control. The product will be open source, and the team is building in the open. Talaria Scientific is built by Distributional, Inc., based in Palo Alto, California, and is in private beta with a small group of researchers. ### Fast facts - **Company:** [Distributional](https://distributional.com), Inc., founded 2023, based in Palo Alto, California - **Products:** Talaria Scientific is the product line: Talaria, the multi-agent research harness, and TauOpt, the Bayesian optimization engine. - **Name:** Say it "tuh-LAIR-ee-uh" (rhymes with malaria). [Talaria](https://en.wikipedia.org/wiki/Talaria) are the winged sandals of Hermes, made by Hephaestus, that flew the god as swift as any bird: science at the speed of thought. Latin talaria, from talaris, "of the ankle". - **Status:** Private beta - **Website:** [talariasci.com](https://talariasci.com) - **Writing it:** Talaria Scientific, two words, both capitalized. Talaria on its own is the harness. TalariaSci is only the social handle. ### Official handles - GitHub: [talariasci](https://github.com/talariasci) - Hugging Face: [talariasci](https://huggingface.co/talariasci) - X: [@talariasci](https://x.com/talariasci) - PyPI: [talariasci](https://pypi.org/project/talariasci/) - npm: [talariasci](https://www.npmjs.com/package/talariasci) - YouTube: [@talariasci](https://www.youtube.com/@talariasci) - LinkedIn: [talariasci](https://www.linkedin.com/company/talariasci) ## Logos SVG for print and design tools, transparent PNG for slides and web, and a white-background JPG for documents that cannot take transparency. The white set is for dark backgrounds; its previews sit on a dark checkerboard so you can see the transparency. The horizontal and stacked lockups (black and white) have no SVG: their type is live text in the source file, so the PNGs are the faithful cut. ### Horizontal lockup (color) - SVG: https://talariasci.com/press/talaria-scientific-logo-horizontal.svg - PNG 2171x746: https://talariasci.com/press/talaria-scientific-logo-horizontal-2171x746.png - PNG 600x206: https://talariasci.com/press/talaria-scientific-logo-horizontal-600x206.png - JPG 2171x746: https://talariasci.com/press/talaria-scientific-logo-horizontal-2171x746-white-bg.jpg ### Stacked lockup (color) - SVG: https://talariasci.com/press/talaria-scientific-logo-stacked.svg - PNG 1783x1033: https://talariasci.com/press/talaria-scientific-logo-stacked-1783x1033.png - PNG 600x348: https://talariasci.com/press/talaria-scientific-logo-stacked-600x348.png - JPG 1783x1033: https://talariasci.com/press/talaria-scientific-logo-stacked-1783x1033-white-bg.jpg ### Sandal mark (color) - SVG: https://talariasci.com/press/talaria-scientific-logo-mark.svg - PNG 1630x1903: https://talariasci.com/press/talaria-scientific-logo-mark-1630x1903.png - PNG 600x700: https://talariasci.com/press/talaria-scientific-logo-mark-600x700.png - JPG 1630x1903: https://talariasci.com/press/talaria-scientific-logo-mark-1630x1903-white-bg.jpg ### Horizontal lockup (black) - PNG 2171x749: https://talariasci.com/press/talaria-scientific-logo-horizontal-black-2171x749.png - PNG 600x207: https://talariasci.com/press/talaria-scientific-logo-horizontal-black-600x207.png - JPG 2171x749: https://talariasci.com/press/talaria-scientific-logo-horizontal-black-2171x749-white-bg.jpg ### Stacked lockup (black) - PNG 1783x1041: https://talariasci.com/press/talaria-scientific-logo-stacked-black-1783x1041.png - PNG 600x350: https://talariasci.com/press/talaria-scientific-logo-stacked-black-600x350.png - JPG 1783x1041: https://talariasci.com/press/talaria-scientific-logo-stacked-black-1783x1041-white-bg.jpg ### Sandal mark (black) - SVG: https://talariasci.com/press/talaria-scientific-logo-mark-black.svg - PNG 1642x1916: https://talariasci.com/press/talaria-scientific-logo-mark-black-1642x1916.png - PNG 600x700: https://talariasci.com/press/talaria-scientific-logo-mark-black-600x700.png - JPG 1642x1916: https://talariasci.com/press/talaria-scientific-logo-mark-black-1642x1916-white-bg.jpg ### Horizontal lockup (white) - PNG 2171x749: https://talariasci.com/press/talaria-scientific-logo-horizontal-white-2171x749.png - PNG 600x207: https://talariasci.com/press/talaria-scientific-logo-horizontal-white-600x207.png ### Stacked lockup (white) - PNG 1783x1041: https://talariasci.com/press/talaria-scientific-logo-stacked-white-1783x1041.png - PNG 600x350: https://talariasci.com/press/talaria-scientific-logo-stacked-white-600x350.png ### Sandal mark (white) - SVG: https://talariasci.com/press/talaria-scientific-logo-mark-white.svg - PNG 1642x1916: https://talariasci.com/press/talaria-scientific-logo-mark-white-1642x1916.png - PNG 600x700: https://talariasci.com/press/talaria-scientific-logo-mark-white-600x700.png ## Usage Do: - Use the color logos on light backgrounds, the black line art for single-color print, and the white line art on dark backgrounds. - Give the logo room: keep clear space of at least the height of the sandal mark on every side. - Use the photos unaltered; take bios and titles from this page, they are kept current. Do not: - Do not recolor, rotate, stretch, outline, or add effects to the logo. - Do not display the sandal mark smaller than 32 pixels tall in print or on slides. - Do not use the logo or the photos to imply endorsement of a product, service, or event. - Do not place the color or black logos on dark or busy backgrounds; use the white set there. --- Source: https://talariasci.com/press ================================================================ # Figures: Talaria Scientific > Every diagram and image from the Talaria Scientific blog, linked to its source post. House diagrams download as attributed SVGs; other images download in their original format. Diagrams and images from the blog, in one place. Open any figure to zoom and pan, follow the link to read it in context, or download it. House diagrams download as SVGs with a copyright line and the link back to their source post bottom-right; other images download as the original files. Figures are the work of Scott Clark and are copyright Distributional, Inc. Each SVG download carries its attribution and the link to its source post. Machine-readable index: https://talariasci.com/figures.json ## Reuse House diagrams (the SVG downloads) are licensed CC BY-ND 4.0: reproduce them unmodified, anywhere, with the attribution footer intact. The download already carries the credit, the source link, and the license. No modified versions: no cropping, re-labeling, or re-branding, and nothing that implies endorsement. Animated variants and other raster images on these pages are not under that license. Ask before reusing them. License: https://creativecommons.org/licenses/by-nd/4.0/ ## Why I'm building Talaria Scientific https://talariasci.com/blog/why-im-building-talaria - [Ideas should set the pace of science: Talaria moves the schlep into the harness, raises the bar to trusted and reproducible, and speeds the flywheel for finding the next idea.](https://talariasci.com/blog/why-im-building-talaria#fig-why-im-building-talaria) - SVG: https://talariasci.com/figures/why-im-building-talaria/why-im-building-talaria.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) ## The scientific flywheel that can lead to abundance https://talariasci.com/blog/the-right-model-for-the-job - [Talaria makes the models, TauOpt picks and searches over them, the harness accelerates both; the outputs serve discovery (fluids, materials, energy) and just-in-time physics for physical AI.](https://talariasci.com/blog/the-right-model-for-the-job#fig-strategy) - SVG: https://talariasci.com/figures/the-right-model-for-the-job/fig0-strategy.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [A simple example frontier: model classes on the accuracy-versus-cost plane. It used to be a handful of hand-built points; the agenda's first half (part 1) is filling it in and pushing it out so there are more and better options to pick from.](https://talariasci.com/blog/the-right-model-for-the-job#fig-frontier) - SVG: https://talariasci.com/figures/the-right-model-for-the-job/fig1-frontier.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [One pass through the loop: cheap surrogates explore the space, the policy exploits what they learn to call costlier models, expensive models verify, and every run (cheap or expensive) improves the next choice.](https://talariasci.com/blog/the-right-model-for-the-job#fig-loop) - SVG: https://talariasci.com/figures/the-right-model-for-the-job/fig2-loop.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [Two wheels on one record: the models and the search improve each other, and use improves the products that spin them. The outputs are honest search for discovery and the right model per task for world models and physical AI.](https://talariasci.com/blog/the-right-model-for-the-job#fig-flywheel) - SVG: https://talariasci.com/figures/the-right-model-for-the-job/fig3-flywheel.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) ## The architecture of the Talaria research harness https://talariasci.com/blog/the-talaria-architecture - [The Talaria architecture. The five-stage Research Loop runs on top of the System of Record; below, the rigor skills augment that process and can extend the record, the inspection skills give you a view into the record at various levels, and the maintenance skills ensure the record is always clean. Capture is cheap, every claim-hardening write passes a gate that checks it against the record's rules, so every hardened claim stays traceable and inspectable, and the adversarial panel rides the gates as claims harden; a failed stage kicks back to a previous part of the loop. The record compounds over time as the process unfolds.](https://talariasci.com/blog/the-talaria-architecture#fig-architecture) - SVG: https://talariasci.com/figures/the-talaria-architecture/fig1-architecture.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [The System of Record, in detail: what each node type is and where it lives, over the append-only journal and its rules file. The record itself is local; below the line is your personal cloud: an external git remote, an Obsidian backup, and a durable artifact store, all optional, all private (the record keeps the pins as pointers).](https://talariasci.com/blog/the-talaria-architecture#fig-sor) - SVG: https://talariasci.com/figures/the-talaria-architecture/fig4-sor.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [One hypothesis walked through the Research Loop from start to finish.](https://talariasci.com/blog/the-talaria-architecture#fig-gauntlet) - SVG: https://talariasci.com/figures/the-talaria-architecture/fig2-gauntlet.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [Who owns what. The field harness is public and Talaria maintains it; your instance is private and yours; the published literature is the commons. Nothing is jointly owned, and every crossing is drawn: upgrades flow to you, /feedback is a report you choose to send back to Talaria, and your methods come back to the harness only by being published publicly, at which point we pull them in like anything else in the literature.](https://talariasci.com/blog/the-talaria-architecture#fig-property-line) - SVG: https://talariasci.com/figures/the-talaria-architecture/fig3-property-line.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) ## Surfing the Frontier Wave that rests between The Bitter Lesson and No Free Lunch https://talariasci.com/blog/no-free-lunch-bitter-lesson - [Scale is a rising wave: each generation submerges more of what specialists built, but the wave advances less and performance falls as validated evidence thins.](https://talariasci.com/blog/no-free-lunch-bitter-lesson#fig-wave) - SVG: https://talariasci.com/figures/no-free-lunch-bitter-lesson/fig1-wave.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) - [The tide coming in: each model generation raises the water, t1 to t2 to t3.](https://talariasci.com/blog/no-free-lunch-bitter-lesson#fig-wave-animated) - image: https://talariasci.com/images/blog/no-free-lunch-bitter-lesson/fig1-wave-animated.gif (© 2026 Distributional, Inc.) - [A harness does more than pick: where the engine and the specialist approach from different directions, the ensemble can exceed the best of its parts.](https://talariasci.com/blog/no-free-lunch-bitter-lesson#fig-ensemble) - SVG: https://talariasci.com/figures/no-free-lunch-bitter-lesson/fig2-ensemble.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) ## A system of record for computational science https://talariasci.com/blog/the-system-of-record - [The system of record: references above, the hypothesis-results-findings triad below, concepts overshadowing all of it. Every result answers a hypothesis and findings carry their evidence with them.](https://talariasci.com/blog/the-system-of-record#fig-system-of-record) - SVG: https://talariasci.com/figures/the-system-of-record/fig2-system-of-record.svg (© 2026 Distributional, Inc.; CC BY-ND 4.0) --- Source: https://talariasci.com/figures (Talaria Scientific) ================================================================ # Blog: Talaria Scientific > Positions, design notes, and build-in-the-open updates from Talaria Scientific: why we are building a multi-agent harness for computational science, and how. Each entry links the post's plain-markdown twin; HTML versions live at `https://talariasci.com/blog/`. Full-content RSS: https://talariasci.com/rss.xml. - [Why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria.md) (July 24, 2026, Positions): Talaria Scientific is building a multi-agent harness for computational science research to accelerate the flywheel of scientific discovery - [The scientific flywheel that can lead to abundance](https://talariasci.com/blog/the-right-model-for-the-job.md) (August 31, 2026, Positions): The scientific flywheel behind Talaria and TauOpt: a dense frontier of physics models, the policy that picks the right one per job, and why that compounds toward abundance. - [The architecture of the Talaria research harness](https://talariasci.com/blog/the-talaria-architecture.md) (August 28, 2026, Design Notes): The Talaria architecture: one scientist, one driving agent, twenty actions around one System of Record, and a gate on every claim-hardening write. - [Surfing the Frontier Wave that rests between The Bitter Lesson and No Free Lunch](https://talariasci.com/blog/no-free-lunch-bitter-lesson.md) (July 24, 2026, Positions): No free lunch says specialization wins; the bitter lesson says scale does. Both are right, and the frontier where they intersect is where science accelerates. - [A system of record for computational science](https://talariasci.com/blog/the-system-of-record.md) (July 24, 2026, Design Notes): The shape of Talaria's system of record: references, a hypothesis-results-findings triad, concepts over all of it, and the failure mode each design choice kills. --- Source: https://talariasci.com/blog (Talaria Scientific) ================================================================ # The scientific flywheel that can lead to abundance > The scientific flywheel behind Talaria and TauOpt: a dense frontier of physics models, the policy that picks the right one per job, and why that compounds toward abundance. Author: Scott Clark Published: 2026-08-31 Series: Positions Canonical: https://talariasci.com/blog/the-right-model-for-the-job --- In other posts I have explained [why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria) and [the architecture behind it](https://talariasci.com/blog/the-talaria-architecture). This is the third leg: What does the world get out of a better computational science research harness? **Better tools to do better science faster is the rising tide that lifts all boats toward human abundance.** The strategy is in four parts: 1. We intend to make validated multi-physics, multi-scale surrogate models cheap and easy enough to produce via the Talaria harness. The goal is a dense Pareto frontier of models to choose from across fidelity and cost for any given job, while simultaneously expanding the volume of that frontier. 2. We will also build the optimization layer, which picks the right model from those surrogate model options for each job and set of goals. TauOpt will be a surrogate-aware Bayesian optimization ensemble that can be deployed locally or accessed via API (or MCP, for agent stacks). It will allow for efficient search over these surrogate models, while also helping optimize them individually. 3. Both of these will be developed inside the [Talaria harness](https://talariasci.com/blog/the-talaria-architecture), which keeps the research reproducible and self-improves as it goes. Each improvement accelerates parts 1 and 2. 4. When combined, Talaria and TauOpt will allow researchers in fluids, materials, and energy to better optimize their products over a dense set of feasible and optimal physics surrogates using surrogate-aware optimization techniques. This means being able to build better materials and run better experiments more efficiently and effectively than before. Additionally, we will be able to select the right just-in-time physics model for physical AI systems in robotics and world models, trading off speed and accuracy mid-task instead of relying on pixel-based models to simulate the real world. I am building Talaria and TauOpt in the open because other people using them directly advances this strategy. Other firms building in the AI x Science space also reinforce this strategy. **This self-reinforcing loop can lead to better discovery in the physical sciences and greater accuracy in physical AI, accelerating our ability to achieve a sci-fi future of abundance.** ![Talaria makes the models, TauOpt picks and searches over them, the harness accelerates both; the outputs serve discovery (fluids, materials, energy) and just-in-time physics for physical AI.](https://talariasci.com/images/blog/the-right-model-for-the-job/fig0-strategy.png) ## Filling in the Pareto frontier of physics surrogates Every field that simulates the physical world has always had a version of the same portfolio of computational techniques. At one end of the spectrum sit full-fidelity methods: the fine-mesh finite element run, the direct numerical simulation, the quantum-level treatment of a molecule. They are considered the reference answers to computational problems, trading off cost for accuracy. At the other end of the spectrum sit the approximate methods: coarse meshes, reduced physics, empirical fits. These methods trade off accuracy for reduced cost. Chemistry has this ladder from coupled cluster and quantum Monte Carlo down through DFT to classical force fields and their coarse-grained reductions; fluids has it in mesh resolution and turbulence closures. Traditionally, this portfolio of options has been relatively sparse: there was a small set of options to pick from because they were difficult to produce. The tradeoffs involved in selecting a model are high-dimensional (fidelity, speed, cost, spatial and temporal scale, which physics are even in the model), but there were certain areas of these tradeoffs where no option even existed. This was because manufacturing one new technique was its own hard project, so each field ended up with a handful of discrete, familiar options and whole workflows designed around them. Some problems could afford the full solution; the rest made do with the closest reduced-order models, response surfaces, and emulators. It was difficult to pick the right tool for the job because there were so few tools to choose from. What has changed over the last several years is the density of *feasible* options in that tradeoff space. Neural operators and learned surrogates can be trained to sit at points the classical stack could not cheaply manufacture (the [DeepONet](https://arxiv.org/abs/1910.03193) and [Fourier neural operator](https://arxiv.org/abs/2010.08895) lines and their descendants, physics-informed variants, tensor-factorization surrogates). Headline papers report speedups of up to three orders of magnitude against traditional solvers, trading off accuracy for speed in ways that were previously impossible (though accuracy-matched comparisons are rarer than the headlines suggest). AI is making it easier to create an increasing number of options along your ideal tradeoffs between metrics. A *surrogate* is any cheap model standing in for an expensive one: a learned operator, a reduced-order model, a coarse mesh, even a Gaussian process fit to a handful of runs. General foundation models sit in this tradeoff space too, mostly at the cheap end with [their physics unvalidated](https://talariasci.com/blog/no-free-lunch-bitter-lesson). *Fidelity* is how faithfully a model reproduces the system you care about, and it is not one number: a surrogate can be faithful on smooth regimes and wrong in shocks, faithful on pressure and sloppy on vorticity, capable of high accuracy but with high variance. The *feasible frontier* is the Pareto frontier of fidelity versus cost: the set of models where you cannot get more faithful without paying more, or cheaper without giving something up. Because fidelity is conditional on the regime and the quantity you care about, there are many of these frontiers, each with a high dimension of metrics to trade off. ![A simple example frontier: model classes on the accuracy-versus-cost plane. It used to be a handful of hand-built points; the agenda's first half (part 1) is filling it in and pushing it out so there are more and better options to pick from.](https://talariasci.com/images/blog/the-right-model-for-the-job/fig1-frontier.png) ## Filling it in is a manufacturing problem The first half of the research agenda (part 1 above) is to fill in that frontier and push it outward, with more multi-scale, multi-physics surrogates so there are more options with different tradeoffs to pick from along it. Traditionally, manufacturing a validated point on these frontiers has been a paper-scale project: generate training data from solvers you trust, train the model, measure its error where you intend to use it, wire it into a workflow, and keep the whole chain reproducible enough that someone else can reuse it. Benchmark suites like [PDEBench](https://github.com/pdebench/PDEBench), [PDEArena](https://pdearena.github.io/pdearena/), and [The Well](https://polymathic-ai.org/the_well/) make measuring new methods easier, but each point needs to be validated where it will be used, with the provenance attached, so a researcher (or an optimization policy) can make sure they are picking the right model with the right tradeoffs. A lot of the work that goes into making these new methods is undifferentiated work like building environments, reproducing baselines, doing massive computational runs, and bookkeeping rather than the novel idea itself. That extra work is exactly what the Talaria [harness](https://talariasci.com/blog/the-talaria-architecture) was built to absorb: it runs the Research Loop that manufactures a surrogate (the training runs, the validation sweeps, the error maps, the record of what was checked against what), so the next validated point becomes a repeatable job instead of a one-off project. Cheaper manufacturing pays in two ways. Density: more points land along the frontier a field already has, and the jump from the model you can afford to the model you trust stops being such a massive leap. Volume: more multi-scale, multi-physics operators reach regions of the high-dimensional tradeoff space (coupled physics, longer horizons, harder regimes) that previously had no affordable or feasible option at all. Having more and better options to choose from lets a researcher or optimization policy pick the very best tool for the job instead of having to settle for close enough. ## The right model for the job, chosen per job Different situations call for different types of models and by picking the right tool for the job you can do better than just blindly applying the same model for an entire task. For example, imagine you're driving on I-70 across the plains, the road is straight and empty, and nothing about the next ten seconds is uncertain: a coarse model of the world, sampled at a low rate, is good enough assuming nothing changes. But then a car appears on the horizon, and suddenly you want a finer model of one region of the world, sampled faster, with a better prediction of what that one object will do. After it passes and the road is empty again you can go back to the simple model until something else changes. Many systems can be optimized in this way: if you are modeling the surface of a calm pond you can use one model, but if there is a shock to the system (a rock is thrown into the pond, etc.) then all of a sudden you may need another model, or another one yet if many shocks occur all at once. To optimally allocate a fixed total budget (spend compute when it matters) or to maximize efficiency at any given time (spend less compute to meet a goal) you need the right fidelity model for the task at hand and you need to know when the task changes underneath you. Modern simulation methods already vary fidelity within a single solve: adaptive mesh refinement and adaptive time-stepping have done it for decades, with adjoint error estimation to say where (focusing attention on what changes most). But there can also be efficiency in adaptively picking the models themselves with information as it streams in. Picking the right tool for the job as the job evolves can lead to both better tool efficiency and a better overall outcome. This problem also emerges when trying to find the best ultimate design of a system when there are many ways to cheaply sample estimates along the way. The classic origin of these methods dates back to kriging in the 1950s, when mining engineers were trying to estimate gold ore grades from sparse borehole samples to decide where to mine next. These methods have been extended to materials design, drug discovery, AI model optimization, and more in recent decades. If you have a fixed budget of questions you can ask, it sometimes benefits you to ask many cheap versions (i.e. surrogates) of the question (even if you get noisy answers) to get close to the right answer before you ask the full question at high fidelity. I have been attacking this type of problem for the last two decades, stretching back to my PhD work and my first startup, SigOpt. By creating better ensembles of Bayesian optimization methods we were able to help thousands of researchers in academia and industry optimize their problems better than they previously could. TauOpt expands on the work I have done in Bayesian optimization by focusing on problems where there are many more surrogates to choose from and there is more prior knowledge on the problem, constraints, budget, and domain. This will allow us to jointly optimize better surrogate methods and also use them to solve hard design problems more efficiently than before. That is where the two halves of the agenda stop being separate projects: good physics surrogates let you run what is essentially digital-twin optimization, with the physics model in the loop instead of a generic statistical prior. My north star for the second half of the agenda (part 2 above): scalable methods for multi-objective, multi-fidelity, multi-surrogate, multi-acquisition-function optimization. ## Two ways to use the resulting frontier One way to use the frontier is routing: a question arrives, a policy picks the model, the answer comes back with its validation attached. The other is search: instead of answering one question, you are hunting through a design space (an alloy, an airfoil, an operating point) where the only evaluations you fully trust are expensive, and sometimes require a physical experiment. The frontier becomes a ladder: cheap surrogates explore the space to learn, the policy exploits this information to call costlier models, and the expensive rungs (the reference solver, then the lab) spend their budget where the cheap rungs have led us. This is the oldest promise of multi-fidelity optimization, and it is where the agenda's two halves multiply: every new validated point on the frontier is another rung the search can stand on, and a denser ladder wastes fewer expensive evaluations on candidates a cheap model could have killed. ![One pass through the loop: cheap surrogates explore the space, the policy exploits what they learn to call costlier models, expensive models verify, and every run (cheap or expensive) improves the next choice.](https://talariasci.com/images/blog/the-right-model-for-the-job/fig2-loop.png) ## The switch has to be trustworthy This agenda lives inside the [harness](https://talariasci.com/blog/the-talaria-architecture) rather than beside it because a portfolio of models at mixed fidelities multiplies the ways to fool yourself. A surrogate that is excellent in distribution can answer fluently out of distribution, and a policy that chases cheap evaluations will happily get misled this way. If switching models silently changes what you can trust, you have sped up the pipeline and broken the conclusions. So the selection machinery needs to have validation within it. There needs to always be the option to project back to ground truth, or the closest thing you have to it (the reference solver, or the experiment). Re-run the answer that matters with the model you trust most, and check it before anything downstream depends on it. Surrogate error gets spot-checked where the surrogate is being used (not just where it was trained). Physical invariants and convergence checks ride along as guardrails whichever model happens to be answering. And every run the policy buys, cheap or expensive, lands in the [record](https://talariasci.com/blog/the-system-of-record) with its provenance, so a conclusion can always answer the question "which model said so, and what was it validated against?" That is what the harness's [record and gates](https://talariasci.com/blog/the-talaria-architecture) were built to hold, and it is why I think of the trust machinery and the selection machinery as one research program: the policy can only afford to be aggressive because the verification keeps it honest. The record ends up holding two ledgers at once. One is each model's validation history (where it is trusted, against what); the other is the policy's run history (what was chosen, what it cost, what it returned). ## The flywheels that accelerate this process The [architecture post](https://talariasci.com/blog/the-talaria-architecture) outlined how the harness gets better over time: each pass through the Research Loop deposits into the record, so the next pass starts further ahead. This agenda adds two more wheels that spin on that same record. The inner wheel turns between the models and the search. During a search over the portfolio of surrogates, the policy decides which expensive evaluations are worth running. Every one of those runs lands in the record with its provenance, and that corpus (reference solves, plus error measured where the surrogates were used) is the training data for the next generation of surrogates. The improvement runs the other way too, because building a good surrogate is itself a search problem over architectures, operator families, and training configurations, with the same objective: expand the volume of the validated frontier a field can choose from. That search is a job for the same cost-aware optimizer. Talaria builds and validates the models, TauOpt searches over and with them, and each side's output is the other side's raw material. The two ledgers in the record are what keep this wheel from slipping: the model ledger says where the models can be trusted, and the run ledger teaches the policy what its choices returned. The outer wheel is slower and larger: the open-science commons spins this outer wheel. The harness will be open source by [NeurIPS 2026](https://neurips.cc/) (December 2026), always free for open scientific work; TauOpt, the optimization engine underneath, will be open sourced along the way. Free local access for open work is deliberate: open work publishes, and publication is what fills the frontier, for everyone, which can then be used to solve this problem faster. I would rather make the frontier cheap for the field to fill than try to fill it alone: every published method, ours or anyone's, becomes a point the field can choose from once a harness has ingested and validated it, and every published policy is a better way to choose. We are giving away the tools that build the tools that are needed to solve the hardest problems. This rising tide of better surrogates and better optimization methods will allow us to tackle the frontier problems in physical AI and world modeling. ![Two wheels on one record: the models and the search improve each other, and use improves the products that spin them. The outputs are honest search for discovery and the right model per task for world models and physical AI.](https://talariasci.com/images/blog/the-right-model-for-the-job/fig3-flywheel.png) ## Why this matters beyond simulation The demand curve for physics-at-many-fidelities is being redrawn right now by teams that mostly do not call themselves simulation people at all. The teams building world models for robotics, autonomous vehicles, drones, and the broader push toward physical AI are consuming physics constantly: generating training data, checking that learned dynamics stay physical, planning against predicted futures, deciding when the learned model can be trusted and when to fall back to something slower and surer. Each of those is a choose-from-the-frontier decision. Some of these decisions already get made adaptively (domain randomization schedules, fidelity curricula, uncertainty-gated fallbacks), but most are hand-tuned, per team, and rarely treated as policies to validate. The agenda is to make that layer explicit, learned, and checkable. Today's world models are mostly trained on video and interaction because video is what exists at scale and a dense, validated frontier of physics models hasn't existed to build on. Physics-grounded models hold up over longer horizons and come with the conservation laws that pixel prediction has to rediscover, and part of the bet is that the next generation of world models gets built on exactly this substrate. Can a robot learn a task better, and cheaper, because the policy underneath it samples the right surrogate at the right moment? The check is ordinary practice in that world: A/B the surrogate where it is used, and A/B the policy on the task reward it serves (the same two ledgers, one level up). The teams that already train robots in simulation face that question today, which makes them the natural entry point for methods like these. The same is true for just-in-time physics models on-device in autonomous systems, where the budget is watts and latency instead of GPU-hours: the question is "what is the cheapest model that is still valid for this decision," which is the frontier question again (good enough but no better). Then there are the industries that were simulation-heavy long before the current AI wave, where I think the impact is most underappreciated. Fluids is the clearest example. Computational fluid dynamics sits inside almost everything that moves, burns, or cools: the aerodynamics of airplanes and cars, the turbines behind most of the grid's electricity, reactor cooling, ship hulls, wind farms, the airflow that keeps a data center's chips alive, combustion, and weather. It is also some of the most expensive physics we compute (a high-fidelity turbulence run takes cluster-days per answer), so engineering practice still leans on coarse models and correlations tuned decades ago. This agenda is aimed at the gap between the model you can afford in the loop and the model you would bet a certification on. A dense frontier of validated fluid surrogates narrows that gap, with a policy that knows when the coarse model is safe (and when only the fine one will do). Materials, energy, and aerospace share the same structure: bespoke models, physical stakes, and design problems that are search problems, which is exactly where honest multi-fidelity search is pointed. I expect a learned, validated selection policy to beat both the single-model default and strong fixed heuristics (verify-the-top-k, hand-tuned fidelity schedules) on validated results per unit of compute. This is exactly what we aim to continue to test in the coming months and years across domains. ## Why now is the right time for this strategy People have worked on multi-fidelity methods and multi-physics coupling for decades ([the multi-physics survey literature](https://doi.org/10.1177/1094342012468181) is a sobering read on how hard the coupling gets), and pieces of this agenda have active communities around them. The strategy for Talaria Scientific is about timing: the frontier is filling in fast enough, and the optimization machinery is mature enough, that treating the portfolio-plus-policy as one system (rather than a solver choice made once in a config file) is now the right architecture for computational science, and soon after for the physical AI stack above it. Talaria the product is general (not scoped to this agenda). It is a harness that helps computational scientists validate their own ideas faster, whatever those ideas are; this agenda is what we are pointing our own copy at, and this strategy is the bet that the product and the research program compound. You do not have to care about my Pareto frontiers to use the tool on yours. The same is true for TauOpt; it is a general-purpose ensemble of optimization methods that can be run on any problem. At the end of the day, my reasons for building this company and executing this strategy are the same ones that pulled me back into research in the first place: if we can empower the world's experts, if we can just make science spin a little bit faster, that is a life worth living and an impact worth having, no matter what the outcome. If you are working on world models, robotics, or anything else that needs the right physics at the right price, I want to hear from you. --- Talaria is in private beta with a small group of researchers. Request access: https://talariasci.com/signup Source: https://talariasci.com/blog/the-right-model-for-the-job (Talaria Scientific) ================================================================ # The architecture of the Talaria research harness > The Talaria architecture: one scientist, one driving agent, twenty actions around one System of Record, and a gate on every claim-hardening write. Author: Scott Clark Published: 2026-08-28 Series: Design Notes Canonical: https://talariasci.com/blog/the-talaria-architecture --- Talaria is a multi-agent, multi-foundation-model harness for computational science research: a scientist directs it, and the harness runs the machinery of in-silico hypothesis validation that is often currently done by hand (the coding, the environment and baseline building, the HPC runs, the record keeping). I have written about [why we're building it](https://talariasci.com/blog/why-im-building-talaria) and about the [System of Record](https://talariasci.com/blog/the-system-of-record) at the center of it. This post describes the architecture of the harness itself: the whole system at once, what each piece does, why each piece is shaped the way it is, and what loops back into what. This post should help you decide whether a system like this would help with your research and give you an overview of how it works. ## What it is A scientist directs a driving agent (a frontier coding agent) that runs twenty named actions as skills against a System of Record that acts as a single source of truth for the entire research process. The Research Loop is at the core: ideas are hardened into plans and concrete hypotheses which are implemented and run on available compute, with the results being synthesized into reviewed findings supporting or refuting the hypothesis; this leads to new ideas and the process repeats. The figure below is the complete inventory of those skills and how they interact at a high level, and the rest of the post dives deeper. ![The Talaria architecture. The five-stage Research Loop runs on top of the System of Record; below, the rigor skills augment that process and can extend the record, the inspection skills give you a view into the record at various levels, and the maintenance skills ensure the record is always clean. Capture is cheap, every claim-hardening write passes a gate that checks it against the record's rules, so every hardened claim stays traceable and inspectable, and the adversarial panel rides the gates as claims harden; a failed stage kicks back to a previous part of the loop. The record compounds over time as the process unfolds.](https://talariasci.com/images/blog/the-talaria-architecture/fig1-architecture.png) The main Research Loop can be thought of as a state machine that builds up the System of Record over time. The Research Loop actions are stages: a stage has a queue of work waiting for it, a session ledger of attempts, and kickback semantics for when a later stage rejects what an earlier one produced. As each stage advances, it writes to its session ledger and updates the System of Record. The driving agent runs each action as a skill (a versioned, auditable instruction set). The user can read (and edit) any of the skills as they go. Every skill pins its inputs and outputs in the journal with their provenance, so an audit follows the pins to an artifact instead of trusting the model's account of what it did. A record full of reproducible runs and an adversarial review panel are the regression suite that guardrails the process as a whole. The underlying skills, models, and driving agents can be upgraded at any time, with a re-validation layer to ensure alignment, so the system can evolve as more capable models become available. An analogy is a sheet thrown over stacked plates: the sheet is the harness (the skills and gates), the plates are the models the labs keep stacking underneath, and the harness re-drapes over whatever is stacked, while the System of Record underneath it all is the artifact that compounds. The high-level goals and constraints of the system are as follows: - Anything the record states must trace back to what produced it: the exact commit, config, seeds, environment, and cost behind every result, so an audit is a lookup instead of an archaeology dig and `/repro` can reproduce any result by construction. - Claims and evidence are bound before any computation is run: pre-registration of hypotheses plus immutable results keep a fast loop from becoming a p-hacking engine. - The scientist owns the judgment and the controls: anything that looks like a scientific conclusion arrives as a proposal, and anything that spends money faces a pre-defined budget gate. - Exploration stays cheap: the rigor of the machinery scales with claim strength, so a what-if costs a conversation, and only the claims you want to harden and eventually publish go through the full depth of inspection and reproduction. - Designed for scale up, out, and across by construction: a university cluster, a national-lab allocation, and a heterogeneous set of neoclouds differ by a config block for the runner only (not a rewrite of the code). - The tools are replaceable and upgradable: models and skills can be swapped as the field moves; the record compounds regardless of the driving agent or underlying models. The harness is "Multi-agent, multi-foundation-model" in three specific ways: the driving agent itself can use many subagents as it invokes each of the actions above, review panels (for ideas, plans, code, findings) fan out many isolated reviewers as subagents using potentially different underlying models, and the model for the driving agent of the system as a whole is the foundation model of your choice (and can change over time). ## What it does The twenty actions come in five groups: the Research Loop skills are the stages of the hypothesis validation work, extra rigor skills harden the work and extend the record as part of this loop or asynchronously, inspection skills produce artifacts from the record at various levels of depth, maintenance skills keep the machine and record clean, and meta usage helps bootstrap and fix the harness itself. The table below is the action catalog of skills: | Skill | What it does | |---|---| | Research Loop | | | `/idea` | captures a thought, with its provenance | | `/plan` | freezes an idea into a pre-registered hypothesis: configurations, seeds, metrics, and what it takes to validate or refute it | | `/implement` | builds and reviews the experiment code that tests the hypothesis | | `/run` | dispatches the work to your compute | | `/synthesize` | proposes findings grounded in the results of the run(s) | | Extra Rigor | | | `/interview` | hardens an idea through inspection, debate, and reference literature | | `/lit-search` | grounds an idea in the literature; registers references with fidelity notes | | `/lit-review` | curates search results into proposed concepts with references | | `/concept-search` | finds the definitions and methods already in your toolkit | | `/concept-create` | registers a reusable definition, metric, or method | | `/review-panel` | attacks a drafted finding with isolated reviewers | | Record Inspection | | | `/status` | tells the user what is done, in-flight, and up next | | `/repro` | re-runs a result from its pins and diffs the outcome | | `/draft` | writes content from a subset of the record | | `/explain` | explains anything in the record, grounded in your references and concepts | | Maintenance | | | `/validate-graph` | checks the graph's invariants | | `/lint` | heals mechanical drift in the graph | | `/close-out` | sweeps the record for loose ends before you share it | | Meta Usage | | | `/init` | personalizes a fresh instance of the repository | | `/feedback` | packages a bug report, with any crash attached | Every action lands in the record's append-only journal. Every action carries a permission class: the actions that spend money face pre-defined budget gates, and anything that looks like a scientific judgment arrives as a proposal to the user; the only way past a gate is an override signed by the user, which lands in the journal like everything else. Nothing phones home on its own (`/feedback` packages a report that you send). The queues and `/status` are both derived from the record on every task, never stored, so there is only ever a single source of truth. The session ledgers carry the mechanical history of what was done (and the record holds the science), so an interrupted afternoon session resumes from the ledger rather than from memory. The ledgers and the record both live in the user's local instance: a stronger model rereading old sessions for anything an earlier pass missed is allowed by construction. ## The System of Record The [System of Record](https://talariasci.com/blog/the-system-of-record) is a single source of truth represented as a research graph of five node types: references (a DAG of what you read: the literature you build on), concepts (a directed graph of what you use: the metrics, baselines, and methods standard to the field), hypotheses (a DAG of what you asked, frozen before you ran), results (a DAG of what ran, immutable from birth), and findings (a DAG of what you now believe, grounded in results). Architecturally, the System of Record is all markdown and JSONL in a git repository, with no database and no server behind it. You can open it in Obsidian and read your own research like a wiki, grep it, or hand the whole directory to a reviewer (human or agent). Large artifacts (ie datasets, checkpoints, rendered plots) live in your own durable store like S3 or R2 and are content-addressed from the run rows; the record itself holds the graph, the journal, and the pins. Because the record is just plain files, every skill can read it, the graph and its history survive any individual tool or session dying, and nothing about the research is held hostage by the product: the agents are replaceable, and the record is inspectable or exportable at any point. ![The System of Record, in detail: what each node type is and where it lives, over the append-only journal and its rules file. The record itself is local; below the line is your personal cloud: an external git remote, an Obsidian backup, and a durable artifact store, all optional, all private (the record keeps the pins as pointers).](https://talariasci.com/images/blog/the-talaria-architecture/fig4-sor.png) The record's connections come in two kinds, enforced by the harness. Typed edges live in the graph itself: which hypothesis derives from which, which result grounds which finding, which finding cites which reference. Following these typed edges answers what evidence this belief rests on, and what exactly produced it, all the way back to the prompt that kicked it off. Actions are events: every action in the system lands as an append-only journal event (an idea captured, a run dispatched, a result born, a verdict set, a gate refused), and a small rules file decides what each event kicks off next. Mechanical, budgeted work fires automatically (a completed run triggers aggregation and plotting; a materialized result triggers graph validation and reindexing), while anything structural or scientific is proposed to the user (never executed silently). Cascade depth is capped, firings per plan are capped, and past either cap everything switches to proposals for the user, so an event storm decays into a to-do list instead of a bill. The rules file itself can be edited at any time. ## How it works: one idea to registered finding, end to end ![One hypothesis walked through the Research Loop from start to finish.](https://talariasci.com/images/blog/the-talaria-architecture/fig2-gauntlet.png) The entire system is designed as a "'What if?' Machine": A user reads a paper and thinks: what if that method holds on my problem class? Talaria helps answer these questions efficiently and effectively so you can ask more and go deeper into the science instead of being mired in the minutiae. The path is as follows: 1. `/idea` writes the "What if?" down with its provenance and any supporting initial context like papers or previous results. 2. `/interview` debates and refines the idea with the user before anything gets built, because an idea alone often isn't enough for a rigorous plan and certifiable hypothesis. This skill surfaces the prior art (using the `/lit-search` subskill) to check whether an idea is already in the literature, asks what the cheapest falsifying test would be, and refuses to co-sign the idea until novelty and impact survive the argument. It fields a fresh-context adversarial referee: a reviewer moved to the front of the pipeline to try to refute that an idea is worth exploring. There is also an escape hatch: you can overrule the interview and let the experiments decide at any point (and the override is also recorded). `/lit-search` grounds the idea in the published literature: parallel searches over the topics, seed papers, and concepts. Sources are found by walking the citation graph outward from seed papers, ranked by influence, and read into structured reference nodes with notes on how faithful each baseline implementation is to its paper. Behind it, `/lit-review` curates what the searches registered into proposed concepts, so a metric, a baseline's quirks, and the right confidence-interval method are waiting for the next loop instead of needing to be reverse-engineered again. 3. `/plan` turns the hardened idea into a hypothesis with a pre-registered contract: which configurations, which seeds, which metrics, and what it takes to validate or refute it, frozen before anything runs. 4. `/implement` sits between the frozen plan and the compute. It owns the experiment code and its tests, with a self-review and a distinct implement-and-review phase before anything touches a shared cluster. The machinery for stamping an implementation scales with claim strength (exploratory or confirmatory): self-review, an adversarial code-review pass at confirmatory grade (separate from `/review-panel`), and a smoke test that runs locally. A stamp pins the exact git trees of the declared implementation and of the whole instance (the current record, experiment code, etc). A dispatch checks its commit against the stamp at the moment it spends money: a committed edit anywhere breaks the match by construction, an uncommitted one already fails the clean-repo gate, and there is no invalidation event to forget to send. A failed run is triaged before more interpretation stacks on top of it, and a failure triaged as a code bug kicks its hypothesis back to `/implement` rather than getting a quick patch (at exploratory grade the kickback arrives as a proposal you can wave through). The stamp check is grade-scoped: it refuses confirmatory dispatches without a valid stamp and only warns exploratory ones (grade is the record's way of recording claim strength). 5. `/run` kicks off the computational experiments, but first it faces the gates. The experiment repo must be committed clean; the remote worker runs a materialized checkout of that exact commit, so the committed source behind a run is never ambiguous. The contract must be complete for the claim grade you are running at; a confirmatory registration with holes blocks before a dollar is spent; exploratory runs are more lenient. Finally, the budget must cover the dispatch. Only after all these checks does the sweep fan out on the available compute. A credential-free local backend can run the same dispatch contract on your own machine, so your first exploratory runs work locally before any cloud account is configured. Beyond local compute, [SkyPilot](https://github.com/skypilot-org/skypilot) is deliberately the only cloud interface in the system: your university Slurm cluster, a Kubernetes cluster, a national-lab allocation, and a commodity neocloud are the same interface, and the gap between them is a backend config rather than a rewrite of your dispatch layer. Every completed run lands as a row in the System of Record carrying the commit hash, the config hash, the seed, the environment fingerprint, the artifact hashes, and the cost (a local run carries the same row, at zero cost). 6. The result is born as an immutable snapshot of the output of a run when the sweep completes, and its coverage is checked against the registration: for example, a sweep that came back with eleven of the twelve promised seeds surfaces as a refusal (not a quiet green). A verdict on the hypothesis can only be measured against exactly one thing: the pre-registered criterion, evaluated on the results of the pre-registered sweep. 7. `/synthesize` drafts a finding grounded in the results, and `/review-panel` attacks it: nine reviewer personas in isolated fresh contexts (a skeptic of AI-generated work, a stand-in for the original method's authors, a baseline-fidelity checker, a statistician hunting selection effects, a systems reviewer, a figures referee, and three more), up to three rounds with critiques pooled between rounds, and a judge body that scores the attacks. The isolation buys each reviewer a fresh context, and a claim promoted to confirmatory grade escalates to referees running on different labs' models. 8. The user decides what enters the record as believed after reviewing the results and findings. 9. `/repro` re-runs a result from its pins, at any later date, and diffs the outcome against the record: bit-exact where the fingerprint matches, within stated tolerance where it does not, and an explicit cannot-reproduce-here when the substrate that ran it is unavailable. A result that moved is a finding in its own right, and it goes back to the panel. The through-line of all the gates in the system is that the harness will fail loudly if any of the preconditions are violated (and the user must explicitly override on the record to continue). The evidentiary gates bind claim strength (not exploration); the operational guardrails (budgets and clean commits) apply to everything, the way seatbelts do; the user can ignore them if they choose to. Exploratory work runs with light checks and full freedom, mess tolerated on purpose; the machinery ramps up as your claims harden toward something you would publish. You can always explore first and let the record self-heal behind you. ## The flywheel The system is explicitly designed to accelerate a scientist's ability to do their research. Each loop through the machine grows the record: new references with fidelity notes, new baselines that now exist as runnable code, new concepts, new results with their full provenance, new findings, and the superseded paths that tell you where not to dig. The next loop starts where you left off: the lit search begins from references already banked, the interview tests a new idea against findings the record already holds, and baselines built in a previous loop come back ready to run. A faster loop on a compounding record is what this architecture is for: the flywheel gains speed with every pass. On the figure, that is the arc from `/synthesize` back to `/idea` (and back again and again). In grad school a single what-if would cost me months; that is the loop this machine rebuilds and collapses toward hours, with the schlep inside the harness and abstracted away, and the user still in complete control. ## Past the loop The rest of the design sits past the single loop. `/draft` writes content from a subset of the record, from blog posts to papers and talks, with every quantitative claim resolving to its pin and figures regenerated from artifacts rather than pasted. The record's format was chosen so one lab's research graph can merge into another's. ## What lives where Everything you download is the field harness focusing on a specific domain like PDE surrogate methods or Bayesian Optimization. It contains the Talaria core (the Research Loop, the gates, and the System of Record machinery), the field pack (the baselines, metrics, and solvers of the chosen domain), the twenty skills, the docs, and a seed knowledge base (starter concepts and references, plus a worked example record you can read before you run anything). Talaria maintains that whole side of the boundary, and that side is public: the skills get upgraded, the field pack grows baselines, the docs improve, and every instance starts from the same repository. ![Who owns what. The field harness is public and Talaria maintains it; your instance is private and yours; the published literature is the commons. Nothing is jointly owned, and every crossing is drawn: upgrades flow to you, /feedback is a report you choose to send back to Talaria, and your methods come back to the harness only by being published publicly, at which point we pull them in like anything else in the literature.](https://talariasci.com/images/blog/the-talaria-architecture/fig3-property-line.png) The instance is the local copy of everything the harness builds around your work, and it is private and yours: your record, your experiment code, your profile and configs, and your papers with their statuses. The record is the research graph and its journal, including the concept graph you accumulate as you go. The boundary between the two is part of the directory layout itself, and the machinery enforces it. An upgrade updates the harness directories and never writes into the instance directories, so a new version of the actions can never rewrite your science. The instance layer is the same set of git trees that the stamps pin, so the boundary you own is also the boundary your runs are attributed to. The seed knowledge crosses the boundary only at initialization: before that it is Talaria-maintained template content, and afterward it is instance content that is modified with your research. The third region is the published literature, and it is public like the harness. Two paths lead out of the instance. `/feedback` is the direct one: it packages a bug report with any crash attached, and it needs to be manually sent. There is no private-contribution path, so your unpublished work never enters anyone else's harness, and the only road back into the harness runs through the literature: when a method from your instance ships in a paper, we pull it into the field harness the same way we pull in any other published method from the literature (we read that commons anyway). The larger flywheel at play is that the harness compounds on what the field publishes, and every instance gets better as its field does, which accelerates publishing new results. ## What is next Talaria is in private beta with a small group of computational scientists today. The harness will be open source by [NeurIPS 2026](https://neurips.cc/Conferences/2026), free for open scientific work, always. If you want to judge the architecture properly, future Design Notes posts go component by component. And if you would rather judge it by using it on your own research, [request access](https://talariasci.com/signup) at talariasci.com. --- Talaria is in private beta with a small group of researchers. Request access: https://talariasci.com/signup Source: https://talariasci.com/blog/the-talaria-architecture (Talaria Scientific) ================================================================ # Surfing the Frontier Wave that rests between The Bitter Lesson and No Free Lunch > No free lunch says specialization wins; the bitter lesson says scale does. Both are right, and the frontier where they intersect is where science accelerates. Author: Scott Clark Published: 2026-07-24 Series: Positions Canonical: https://talariasci.com/blog/no-free-lunch-bitter-lesson --- Two famous ideas often get invoked to justify opposite strategies. The no-free-lunch theorems say that no method outperforms the rest unless its assumptions match the problem in front of it, and they get cited to argue that specialists always win (by going broad, you can't beat a method going deep). The bitter lesson says that scale (generalization) beats cleverness (specialization), and it gets cited to argue that you should stop designing bespoke models and features and just ride the scaling curve. Most people quote whichever one helps them win the argument they are trying to make. Both are right about the claims they actually make, and the frontier sits where they intersect. That intersection is good news if you do science for a living: the interesting research lives past the edge of what any engine has validated (out of distribution), and the engines keep making working at that edge easier (accelerate through distribution). Below I'll define both ideas precisely, walk through where each one applies, and lay out what the intersection means for where you should spend your own time and effort. ![Scale is a rising wave: each generation submerges more of what specialists built, but the wave advances less and performance falls as validated evidence thins.](https://talariasci.com/images/blog/no-free-lunch-bitter-lesson/fig1-wave.png) **No free lunch** is a family of theorems [Wolpert and Macready proved in 1997](https://ieeexplore.ieee.org/document/585893). What the theorems prove: averaged over all possible problems, every optimizer performs identically, so any real advantage must come from assumptions matched to a restricted problem class (knowing and leveraging a prior). That motivates specialization, but it does not hand the specialist a guaranteed win. The intuition is: pound for pound, the specialist beats the generalist on its home turf. This is an empirical specialization claim, not a No Free Lunch corollary. An explicit example: at current model sizes, a generic LLM does not beat a classical numerical PDE solver on the solver's validated problem class out of the box, even if it can explain how the PDE works and the historical literature around it in natural language. **The bitter lesson** is [Richard Sutton's 2019 essay](http://www.incompleteideas.net/IncIdeas/BitterLesson.html) observing that, across 70 years of AI research, general methods that can soak up computation (search and learning) keep beating methods built from human knowledge of the domain. The intuition is: scale beats cleverness. It is not a theorem, and it is not a guarantee, but it is a historical pattern across the cases Sutton surveys, and it has held up time and time again in AI over the last decades. **An ensemble** is a family of methods brought to solve a problem together. The simplest form is a router: something decides which method to trust on each piece of the problem, finding the right tool for the job, chosen per job. The stronger form is compositional: the methods exchange information and constrain and learn from each other as they work. The distinction is important in the harness argument below. ## What no free lunch says The statement gets overclaimed routinely, so it's worth getting the precise version right. Take a finite search space and a finite set of possible objective values, weight all possible objective functions uniformly, and consider any optimizer that never revisits a point. Averaged over that space of problems, every such optimizer sees exactly the same distribution of results for a fixed evaluation budget. Your clever algorithm, my clever algorithm, and random search without replacement come out identical. Under that uniform average of all possible objective functions, any advantage on one class of problems is paid for on the complement. Loosely put: if you are good at one thing you are probably bad at another, and if you are ok at everything you pay for that by not being great at any specific thing. The theorem does not say a specialized tool always wins in practice, because real problems aren't drawn uniformly from the space of all functions. What it says is narrower and more useful: outperformance has to come from somewhere, and the only place available is the match between your method's assumptions and the actual distribution of problems you face. If your method beats random search, it's because its priors line up with your problem class. **The gain lives in the match, not in the method.** I built a company on robust black box optimization methods, so this theorem sat underneath everything we did. The work was never about trying to beat the No Free Lunch theorem; it was about closing the efficiency gaps it allows. On the problems SigOpt targeted (expensive evaluations, moderate effective dimensionality, response surfaces well-enough-behaved for certain kernels) there is a large gap between random search and naive Bayesian Optimization (BO), and another between naive BO and clever BO, and closing those gaps was the business. Note which part is which: the expense of the evaluations is the reason to reach for BO at all; the smoothness is the assumption a GP model makes, etc. When the assumptions held, the method was sample-efficient. Where it weakened (very high-dimensional, discontinuous, or heavily categorical problems) the advantage narrowed, and occasionally a customer brought a problem where other methods, including genetic algorithms, were competitive under the same evaluation budget. The gain lived in finding the match for each problem and a router that could find these matches. The limits were when that still couldn't beat the custom method for that specific problem. ## What the bitter lesson says In 2019 Richard Sutton wrote down the pattern he'd watched repeat for decades: "The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin." The general methods he means are search and learning, the two that keep scaling as compute gets cheaper with Moore's and Huang's Laws. History mostly backs him, though the details are sometimes messier than the retellings. Deep Blue is remembered as brute-force search beating grandmaster knowledge, but [the team's own account](https://doi.org/10.1016/S0004-3702(01)00129-1) describes chess-specific hardware, hand-tuned evaluation features, and grandmaster consulting: a specialized structure wrapped around massive search. Hand-engineered vision features like [SIFT](https://doi.org/10.1023/B:VISI.0000029664.99615.94) were displaced from the leading image-classification benchmarks by convnets once data, GPUs, and training technique caught up, a trajectory that took years. And in 2017, AlphaGo Zero trained without human game data (self-play under the supplied rules of Go) and defeated AlphaGo Lee, the version that had beaten Lee Sedol, a hundred games to nothing ([Silver et al., 2017](https://www.nature.com/articles/nature24270)). The direction is real, but the bitter part is personal: careers of carefully built-in human knowledge, outrun eventually by whoever bet on the scaling curve. Each idea also has a lazy reading. The lazy reading of Sutton: design is obsolete, wait for the next model, there is no hope in trying. The lazy reading of No Free Lunch: a specialized tool, once built, is safe indefinitely, there is no hope in competing. Both readings are comfortable, and both dissolve once the two claims are stated carefully enough to compare. ## Where each one applies Stated carefully, the two ideas are not even in tension, because they do not run on the same axis. No free lunch is a distributional result: sustained outperformance requires assumptions matched to a non-uniform problem class. The bitter lesson is a historical observation about which kinds of methods kept improving as computation got cheap: in the cases Sutton surveys, the general methods walked past the specialists, again and again, once there was *enough data and compute* to spend. Abundant compute that unlocked massive scale did not repeal the theorem, and the theorem does not cap the scaling curve. What compute changed is where the required match comes from, and in areas where data is scarce there are still lessons to be learned. When compute is scarce, you get one bet, so you encode everything you know about the problem into it: the features, the heuristics, the grandmasters in the room. In board games the expensive part was never checking the outcome (legal moves and terminal results cost almost nothing to compute) so the cost lived in encoding the knowledge and tactics, and under those budgets encoding was the right play. Science is not a board game, though: the evaluation of a hypothesis is often the dominant cost. When compute is abundant, you no longer have to manually encode the domain. You can train over broad representations and let data select from a hypothesis family no human could enumerate: searched architectures, learned features, training runs and the long tail of post-training after them. Representation, objectives, curation, and validation all remain part of the method; the hand-encoding is the part that shrinks. A large trained model is the outcome of that paid-up search: one hypothesis selected from an enormous family, under the fixed biases of an architecture, an objective (or set of evals to overfit to), and an optimizer, with the data and the training objective doing the picking. It can express many task-conditional behaviors, which is what makes it feel general. Its assumptions did not vanish; they moved into the architecture and the training recipe. The lunch still isn't free, scale just buys more of the menu. The match between assumptions and problems still has to come from somewhere; what changed is how. We used to pay in human priors, one method at a time. Now we mostly pay in compute and data, wholesale. And the wave keeps rising wherever compute and in-distribution data keep scaling. ![The tide coming in: each model generation raises the water, t1 to t2 to t3.](https://talariasci.com/images/blog/no-free-lunch-bitter-lesson/fig1-wave-animated.gif) *The tide coming in: each model generation raises the water, t1 to t2 to t3.* The picture for this is a wave. Problems run left to right by how much evidence exists for ones like them (the axis is anchored to a fixed snapshot of the evidence, so a problem keeps its place while the curves above it move), and every gray peak is a specialized method, each buying height with narrowness (specificity). The blue curves are successive generations of the general engine, and each generation raises the water: the small peaks on the left have been under water since t2, the taller one held out until t3, and Sutton's seventy years are this tide coming in. The right side of the picture is where it gets interesting for a researcher: where the validated evidence thins, the wave advances less and the waterline falls, and the specialized solver out in the band still stands above it. Nothing in the picture says the wave stops rising. It says the wave rises where the data is. The precise reconciliation, then: sustained outperformance requires assumptions matched to your actual problem distribution, and scale is the most successful way the field has yet found to manufacture that match wherever the data exists to learn it from. Scale buys generality over a distribution. It can even help generate evidence where a valid signal exists: synthetic data, simulation, self-play, automated experimentation. What it cannot do is determine behavior in a regime with little evidence and no assumptions connecting that regime to the ones observed. To be precise, **out of distribution** here means outside the regime where the engine's performance has been trained and validated, because the mechanism shifted, the inputs shifted, or the evidence was never collected. Out of distribution is precisely where research lives. ## Where the engine runs out That paid-up search is only as good as whatever data is in the evidence. Where evidence is dense, training has usually selected the right behavior for you already, which is why a benchmark-shaped question feels free: the match was purchased years ago and amortized over everyone. Out of distribution, the engine doesn't refuse to answer, and a refusal would almost be safer. This leads to spiky intelligence: it can disprove a decades old conjecture by putting together known math in other domains, but it still tells you to walk home from the carwash. Take a question from the working end of computational science: how a particular numerical method degrades in a physical regime well past anything in the published record or data. Even a model with broad literature coverage has only a thin file of evidence there, and thin evidence doesn't stop a model from answering. It produces a plausible extrapolation from adjacent regimes, fluent and formatted, and the fluency is not a calibration signal. The answer came from the model's learned distribution over what answers look like, not from evidence about your regime, and nothing external has validated it. That sets up the failure mode: accept it as a baseline, and every downstream comparison inherits it. Weeks later, what reads as an improvement can be a measurement of the baseline being wrong, with nothing in the pipeline positioned to notice. In a chat window, this failure mode looks like a hallucination. In a research campaign, it compounds into bad science. So the bet is not a specialized model; it's a specialized structure around a general model, where the structure knows when and how to call the engine and when and how to call a specialized method. Call that structure a harness: the fixed apparatus around the engine that decides what gets asked, what gets checked, what tools get called, and what gets believed. The point of the whole apparatus fits in one sentence: give the general model the tools to learn what it does not know, and the physics guardrails (or your domain's equivalent) so that nothing unsupported enters the record unlabeled; every output gets verified, rejected, or explicitly marked as an abstention before anything downstream depends on it. A model can always generate a guess; the guarantee lives in what the system accepts. For a proposed numerical result, acceptance looks like this: run a numerical solver at multiple resolutions, check units and invariants, require convergence, compare against a declared baseline, and keep the provenance of every step. ## More than the best of its parts An engine plus a specialist method, held in a harness, is an ensemble, and the simplest way to run one is as a router: send each problem to whichever method is better there. Then collect, problem by problem, the best of the parts, the upper envelope of the two methods, assuming the router always knows which one to pick. A real router approaches that envelope only as far as its selection signal can predict, on problems it has not seen, which method to use, and earning that signal is a large part of what a harness is for. But the max of the methods is not the ceiling, because a router is not the only ensemble. Run the members compositionally (the engine proposes where the specialist is rigid, the specialist constrains where the engine would guess, each catches errors the other cannot see) and the combination can do better than either member does alone. That is the operational meaning of "approaching the problem from different directions": each member contributes information the other does not have, and their failure modes do not fully overlap if they are even slightly orthogonal. An LLM that knows how to use a solver well can be stronger than the LLM or the solver alone. The existence proofs are already published: [FunSearch](https://www.nature.com/articles/s41586-023-06924-6) paired a language-model proposer with an automatic evaluator and produced new mathematical constructions, [AlphaProof and AlphaGeometry](https://deepmind.google/discover/blog/ai-solves-imo-problems-at-silver-medal-level/) pair one with a symbolic verifier and reach olympiad-level validated results, and [AlphaGo](https://www.nature.com/articles/nature16961) itself was networks plus tree search, stronger than either component alone. The fence is worth drawing honestly: the gain is conditional, not automatic. It has to be validated on held-out problems, it shrinks as the methods' errors grow redundant, and it closes to zero where one method adds nothing after conditioning on the other (ie running the same deterministic method twice). It is also a capability claim rather than an efficiency claim: the ensemble spends the engine plus the specialist plus the orchestration between them, so whether it also wins pound for pound is an empirical question under a matched budget. ![A harness does more than pick: where the engine and the specialist approach from different directions, the ensemble can exceed the best of its parts.](https://talariasci.com/images/blog/no-free-lunch-bitter-lesson/fig2-ensemble.png) In the figure, the dashed line is the oracle upper envelope of these two components: the best a perfect router could collect from these two methods, problem by problem. It rides the engine where the engine wins, kinks at the crossover, and rides the specialist where the specialist wins. The solid curve above it is the harnessed ensemble. The sketch assumes the members have nearly nothing to teach each other at the edges, so the ensemble sits near the envelope there; near the crossover, where both members carry non-redundant information, it rises above. Error redundancy is a condition of the claim, not something this axis displays, and the curve illustrates the claim rather than evidencing it. The gap near the crossover is what you gain from a well designed harness over both methods. It is the application that lives on the compute substrate of the methods it harnesses. ## Where the specialization lives The harness carries at least three kinds of structure, and none of it has to live in weights; parts can be learned, a router or a calibration model, without changing the argument. The first is what a valid experiment is in this domain: the units, the invariants, the convergence criteria, the checks a good referee would run. The second is routing: which calls are in-distribution for the engine (write the plotting code, summarize the literature) and which need verification first (propose the baseline, interpret the anomaly). The third is what a claim has to survive before it counts as a result: comparisons declared before the evaluation when the claim is strong enough to warrant it, honest statistics, replication. Exploratory work runs under lighter confirmatory gates (it's confirmation that has to be earned) but provenance, physical constraints, and the speculative label never come off. The scientist pushes out of distribution using specialized methods as guardrails and the foundational model helps fill in behind. None of this re-derives what the engine already knows. All of it is selection, constraint, and validation: the part of the match the data hasn't paid for yet, supplied from outside. That's where no-free-lunch specialization went: out of the weights and into the protocol. ## Maybe scale eats the harness too The strong version of the pure-scale position: everything I just described is scaffolding, and Sutton's essay is a list of scaffolding that got eaten. Every year the frontier of "needs a specialist" recedes; questions that needed careful tooling in 2023 are chat-window questions now. A consistent Suttonian would say the harness is another layer of manually engineered domain structure, and its turn is coming. If you are in grad school right now, watching models prove theorems left and right on twitter between problem sets, this is the version of the argument that keeps you up at night: why spend five years becoming a specialist if the wave is coming for specialists? I'm taking the other side for science in particular. Some of this scaffolding will get absorbed; probably a lot of it over a long enough time horizon. But I believe there will always be a frontier, by definition. Whatever is on the edge of being absorbed is still out of distribution, unknown, and worth exploring. As the models absorb more the frontier moves too. Which is why the time becoming an expert is not wasted: the specialist who explores and works at the moving edge gets to the interesting questions faster than anyone and stays there. And even if the wave rises faster than I expect, there is a reason to play anyway, and it's the part that excites me most. Accelerating scientific discovery is worth doing whether the acceleration ends up living in the model or in the harness. If a harness makes science faster and more effective for a decade and then gets absorbed, the discoveries stay discovered, and the abundance they bought does not get returned. The integral of abundance is maximized. The harness can lose in the very long run and the bet still pays, because at the end of the day more science, sooner, is the prize either way. ## The bet This thesis is what [Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria) is built on: a harness for computational science that carries the domain's structure (convergence checks, physically grounded baselines, statistical gates, provenance) and treats the general models as engines that keep improving underneath it, so the scientist stays on ideas and taste. How the harness estimates its routing signals, draws its out-of-distribution boundaries, and measures error redundancy is its own series of design notes, and that series is on its way. If you're deciding where to spend your own time and effort, the posture falls out directly. Where the engine is validated for your accuracy, cost, and reliability bar, don't fight it; any part of your tool that only compensates for weak general capability is on the engine's menu next (the classic ChatGPT wrappers of the world). Out of distribution, your cleverness is the match, and it is more than verification: spend it first on the ideas and insights nobody has published, the experiments nobody has run, and then on the objective, the baselines, and the selection signal that lets you trust what comes back. The checks exist to serve and accelerate the ideas, not the other way around. Pushing into territory no one has validated, with better instruments than the generation before, is what science has always been: the mirrors, then the computers, and now the engines each took over the part they could hold so the questions could move further out, the flywheel could spin faster. The promise of abundance sitting behind all the AI noise (the new materials, the cheaper energy, the medicine nobody has designed yet) does not arrive on its own; it arrives one validated result at a time, pushed by people working past the edge of the record, and that mantle is on us. The difference is the pace we can push at: with the schlep in the harness and the record keeping itself, the flywheel from idea to trusted result to next idea spins faster than it ever has. If you are the one doing the pushing, the wave is not your competition, it is a surfing opportunity. --- Talaria is in private beta with a small group of researchers. Request access: https://talariasci.com/signup Source: https://talariasci.com/blog/no-free-lunch-bitter-lesson (Talaria Scientific) ================================================================ # A system of record for computational science > The shape of Talaria's system of record: references, a hypothesis-results-findings triad, concepts over all of it, and the failure mode each design choice kills. Author: Scott Clark Published: 2026-07-24 Series: Design Notes Canonical: https://talariasci.com/blog/the-system-of-record --- Talaria keeps a system of record underneath your research: every idea, run, result, and decision, kept with its provenance, whether or not it worked out. We have argued ([Why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria)) that validation, not ideas, bottlenecks computational science, and that a harness can take the schlep without taking the science. This piece explains the memory systems that make that safe: how the record is structured, and why each structural choice was made, failure mode by failure mode. ## The cold restart problem If you put a project down in May and pick it up in September the first week or more back goes to archaeology. What did I try last? Which variants actually ran? Which configuration produced the plot in the draft? Why was the second baseline abandoned? Did the "good" result predate or postdate the preprocessing fix? This is compounded if you hand the project to a collaborator, or a new student, or a skeptical reviewer. The research often moves faster than the record keeping, every interruption resets the context, and the incentives all point at the next result, not the receipts of the last one. A lab notebook only works if the scientist keeps it up to date, and there are better uses for attention. So the record slowly diverges from the work, and everything downstream of the record (reproduction, collaboration, review) inherits the gaps. The system of record we have built inverts the lab notebook ritual: a record the work keeps of itself, instead of one the scientist has to remember to keep. When the harness runs your validation, the bookkeeping is not a separate chore that competes with the science; it is a side effect of the machinery doing the work. We have built the shape that record should take in a very opinionated way, which we explain below. ## The shape At the top of the system of record sits a citation directed acyclic graph (DAG): the literature you build on, linked so every claim traces to its source chronologically and by reference. The graph is directed because each reference cites others and acyclic because, in the record, you can't cite the future. Below it grows a triad of hypothesis, results, and findings DAGs. A hypothesis graph holds what you're explicitly asking for each experiment/run. A results graph holds what actually ran, each result carrying the exact code, configuration, and environment it ran with; exact, because that is what makes a rerun a reproduction instead of a reenactment. A findings graph holds what you now believe, an updated posterior from the results, each finding pinned to what led to it. These graphs are directed because each new entry comes from what was learned before and acyclic because that is how the scientific process behaves by construction; you hypothesize, test, and then learn. Overshadowing all of these DAGs is a concept graph: the living map of definitions and connections the other graphs share, information about the field, baselines, definitions, statistics, and more. Time flows down the page, the references above the ideas, the work growing beneath it. ![The system of record: references above, the hypothesis-results-findings triad below, concepts overshadowing all of it. Every result answers a hypothesis and findings carry their evidence with them.](https://talariasci.com/images/blog/the-system-of-record/fig2-system-of-record.png) The layers are separated intentionally; what you read, what you ask, what you run, and what you believe are different kinds of claims with different lifetimes and provenance. A system of record should not blur them (ie a notebook page where a citation, a hunch, a number, and a conclusion share a line) because it can't answer the questions that matter later: what evidence does this belief rest on, and what exactly produced that evidence? In the record, those questions are edges you follow on a graph, not memories you reconstruct. ## Five design decisions, and the failure mode each one kills This structure was built in an opinionated way, and each is a design choice aimed at a specific way research bookkeeping can go wrong. An untested hypothesis is first-class. Parked ideas aren't clutter, they're your research agenda: the queue you, a student, or the harness can pick up next. The failure mode this kills is the one the manifesto ([Why I'm building Talaria Scientific](https://talariasci.com/blog/why-im-building-talaria)) opened with: the reviewer suggestion, the seminar question, and the shower thought all evaporating because nothing held them. In the record they wait, visibly unpaired with results, until someone (or the harness, within its budget) picks them up. A result that answers no hypothesis is not allowed to exist. Orphan numbers are how spurious findings start: fifty configurations ran, [one "worked,"](https://xkcd.com/882/) and nobody remembers what question it was answering. Forcing every result to name its hypothesis is the structural version of pre-registration: entries are timestamped and append-only, so whether a hypothesis preceded its results is a fact of the record, not a claim in the paper. That is what makes "we tried 50 things and report the best one" visible in the record instead of invisible in a results folder. Superseded ideas get marked, never deleted. Research doesn't evolve cleanly, it morphs and branches, and a record that only keeps the current story is the polished paper's hindsight trail. Keeping the whole history means you can revisit abandoned paths when a new tool makes them viable, hand a collaborator what actually happened instead of a reconstruction, and even publish the roads not taken. Overrides are journaled. The scientist can force past an integrity gate (sometimes you should; a hunch can lead to a breakthrough), but the override itself is recorded along with the exact checks it waived. The failure mode this kills is silent rule-bending: the gap between "we followed the protocol" and what happened, which no one intended and no one can find later. The record stays honest even where you overruled it. The record self-heals before you publish. Mid-flight mess is tolerated on purpose, because rigor that blocks serendipity would be its own failure; science sometimes lurches forward by stumbling into things. Claims are gated by strength, never existence: a lucky observation enters the record labeled as what it is, and earns its confirmation later. When you are done, the harness walks the record with you and heals what's incomplete, and the heal itself is journaled like any override, so a repaired record never masquerades as an original one. Every result you plan to publish is one you can trust and reproduce exactly. ## What standard techniques miss Each standard tool holds a slice of this. The lab notebook (paper or electronic) holds the narrative, but it is only as complete as the scientist's discipline on their worst week, and it isn't linked to the artifacts: the notebook says what you meant to run, not what ran. The wiki or shared doc holds the write-up, prose about runs rather than the runs themselves. The experiment tracker holds the opposite slice: metrics and configurations logged automatically, with the questions nowhere, so orphan numbers are the default rather than the exception, sometimes lost in flat-file-hell (ie "results-final-v2-final-final.log"). None of them is built to hold the whole causal chain, from a claim in a draft back through the finding, the results, the hypothesis, and the references that motivated it. Pieces of this chain exist across provenance standards and workflow tools, and the deep dives in this series will name them and position relative to them; what none of them holds is the whole chain, attached at the moment of execution. The system of record is that chain, kept as structure. It is not a better notebook next to the work; it is the work's own trail, with the provenance attached at the moment each step happens, by the machinery that ran the step. This not only allows you to research with confidence, it also means every result you publish carries what a rerun needs, now and in the future. ## What the shape buys you For you, the researcher: put the project down in May, pick it up in September, and start where you left off, because the record holds the state your memory dropped. For your collaborators: they walk your actual search, dead ends included, instead of your recollection of it. For your readers and reviewers: the trail from claim back to code, configuration, and environment is there by construction, kept automatically, and the full search is visible, not just the winners. We believe the pace of science should be set by the ideas. The system of record is where the ideas, results, and findings all live. So you and others can stand on a strong foundation when continuing to push forward into the frontier ([Surfing the Frontier Wave that rests between The Bitter Lesson and No Free Lunch](https://talariasci.com/blog/no-free-lunch-bitter-lesson)). --- Talaria is in private beta with a small group of researchers. Request access: https://talariasci.com/signup Source: https://talariasci.com/blog/the-system-of-record (Talaria Scientific) ================================================================ # Why I'm building Talaria Scientific > Talaria Scientific is building a multi-agent harness for computational science research to accelerate the flywheel of scientific discovery Author: Scott Clark Published: 2026-07-24 Updated: 2026-08-28 Series: Positions Canonical: https://talariasci.com/blog/why-im-building-talaria --- 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 that currently gets done manually (the coding, the environment building, the HPC runs, the record-keeping). 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](https://distributional.com/blog/distributional-is-now-talaria). ## 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](https://scottclark.io) on different versions of one problem: finding the bottlenecks in this process and accelerating through them. 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 and 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](https://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](https://distributional.com) 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. 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. The target is 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 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 not the same job as publishing a result that claims some truth about the universe and needs to be defensible forever. An agile board of tickets and pull requests does not fit 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 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 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: 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](https://talariasci.com/blog/the-talaria-architecture)*, 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. The work is still trustworthy, valid, and reproducible science, but now you don't need to manually perform every step. A *[System of Record](https://talariasci.com/blog/the-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. ![Ideas should set the pace of science: Talaria moves the schlep into the harness, raises the bar to trusted and reproducible, and speeds the flywheel for finding the next idea.](https://talariasci.com/images/blog/why-im-building-talaria/why-im-building-talaria.png) 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 always one 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 moves one idea through sooner, and the whole flywheel spins faster. ## The mech suit Software engineering has the concept of the "10x engineer," someone who can do the work of 10 median engineers; those 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. 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](https://talariasci.com/blog/no-free-lunch-bitter-lesson)). 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 clean. The human stays on ideas and taste while 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). There are 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](https://talariasci.com/blog/the-system-of-record) underneath the work, making 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: 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](https://xkcd.com/882/)). The component that holds all of this is the System of Record, and it was built in an opinionated way. A reference graph sits at the top (the literature you build on, linked so every claim traces to its source), with 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). A concept graph overshadows 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](https://talariasci.com/blog/the-system-of-record) and why each choice was made. 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, 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. 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](https://neurips.cc/) and always free for open scientific work. You can see [how we are building it](https://talariasci.com/blog/the-talaria-architecture). 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](https://docs.google.com/forms/d/e/1FAIpQLSdmgoEwtl7zgeoRjpD3au_Sz2eoK44HUgkW6LZV0aBpR4g2IA/viewform) if you want to work with us. --- Talaria is in private beta with a small group of researchers. Request access: https://talariasci.com/signup Source: https://talariasci.com/blog/why-im-building-talaria (Talaria Scientific)