A research agent should leave a record, not just an answer
The current generation of scientific agents can read more, run more, and hypothesize faster than any lab on earth. Almost none of them can tell you where a number came from six months later. That gap is the whole product.
The last two years have been extraordinary for scientific agents. Systems now exist that will read a field's entire literature and propose hypotheses ranked against each other. Others will run hundreds of independent analysis trajectories overnight and surface the handful that survived. Open-source agents can plan a CRISPR screen, annotate single-cell data, and predict ADMET properties from a single natural-language request.
The oracle problem
Nearly every scientific agent built so far is an oracle. You bring it a question, it goes away and thinks very hard, and it returns an answer. Then it forgets you.
That shape has four consequences, and they compound.
It can only tell you what somebody already wrote down. Agents that reason over the literature — however many papers, however cleverly ranked — inherit the literature's ceiling. The most interesting thing in your lab right now is probably a result nobody has published, in a file nobody outside your group has opened. An oracle grounded in PubMed cannot see it.
It mistakes volume for judgment. "Hundreds of analysis trajectories, overnight" is a real capability and an odd thing to lead with. Running every path is what you do when you can't tell which path is worth running. You still have to decide which of those hundreds to believe, and the agent has handed you more to check, not less.
It asks for your data first. Most of these systems are cloud platforms. Before the impressive part happens, your unpublished results, your patient-derived data, or your collaborator's pre-print have to be uploaded to somebody else's infrastructure. For a lot of labs that's a legal review, an IRB conversation, or a flat no. The best agent in the world is worth nothing if your data can't reach it.
It leaves no record. This is the one that actually bites. An oracle produces an answer, not a lab notebook. Six months later a reviewer asks which version of the counts matrix produced Figure 3, and the agent that made it has no memory of the conversation, no link between the table and the plot, and no way to reconstruct what it did. You are back to reconstructing it by hand — except now the work you're reconstructing wasn't yours.
There's a fifth, quieter one: none of these tools are where your work already lives. Your files, notes, papers, protocols, samples and half-finished drafts are scattered across a filesystem, a reference manager, a spreadsheet and a shared drive. The agent sits outside all of it, and you are the integration layer.
What we built instead
ARC is not an oracle. It's the agent inside Heureka Bench — a lab notebook that runs on your own machine — and it works the way a good colleague does: in your workspace, on your files, leaving a trail.
It starts where your data already is
A project in Bench is a directory on your disk. ARC reads it, runs analysis against it, and writes results back into the same folder. Nothing is uploaded to make that work and nothing is converted into a format only we can read.
So the question stops being "what is known about this gene" and becomes "look at the counts table in data/, tell me which comparison is worth following, and draft the methods paragraph for the one you pick."
It records where things came from, while it works
ARC captures lineage as a side effect of doing the work. Make a plot from a table and the link between them is recorded without anyone asking for it. Over a project this accumulates into a map of how your samples, reagents, animals, experiments and datasets actually connect — browsable as a list or a graph, and complete enough to generate a methods note with a provenance table straight out of a record's history.
This is the difference between an answer and a result. An answer is something you were told. A result is something you can defend.
It stays
Each project keeps its own conversation, and those conversations run in the background — switch projects, close the panel, walk away, and ARC is still working when you come back. Work that should happen on a schedule does: a weekly data-quality check, a standing literature sweep, a monthly diff of what changed in a dataset. The Activity board shows what's queued, what's running, what needs a decision from you, and what finished overnight.
And it remembers the project. A conversation in week six doesn't start from the same blank page as week one.
It can be taught, once
A protocol you explain repeatedly is a protocol the agent should already know. Skills are exactly that: write the procedure down once, and ARC follows it every time after — the same way, which is the part that matters for reproducibility.
Skills are also shared. There's a public registry at heurekaskills.com, browsable from inside the app, and ARC will go and fetch one itself when you ask for something it has no procedure for. Every skill is reviewed before publication and checksum-verified on install, and installing one never silently overwrites a skill you already have. If you write a good one, you can publish it under your own name.
It can be told no, and prove it
Turn on Privacy Mode for a project and everything that would move data off your machine is switched off: web access, literature and database lookups, cloud jobs, ingest, sync. ARC keeps working on your local files and refuses the rest out loud, and background and scheduled tasks in that project follow the same rules.
The part we're proudest of is the accounting. While Privacy Mode is on, the chat shows a live receipt of every network action — and every blocked attempt, with its reason — and each run appends a plain summary to a log inside the project. It's a claim you can audit rather than a promise you have to take on faith.
A model trained on experiments, not text
Underneath ARC sits Archimedes, our own multi-omics model. It learned the structure of human biology from hundreds of thousands of real experiments, and it places any sample into a single batch-free, platform-invariant space.
That turns a class of question from hard into routine. Hand ARC a dataset and it can put your samples next to hundreds of thousands of real ones: mislabels and batch effects surface on their own, the cell line or mouse model you're using gets matched against the patient samples it actually resembles, and the experiments worth running next can be ranked rather than guessed at. Results come back structured and sourced, tagged with their confidence and caveats.
Compounds get the same treatment — resolved from a name, CAS number or structure rather than recalled, so what lands in your record is something that was genuinely looked up. And when an analysis is the wrong shape for a laptop, ARC can hand that single job to our cloud and bring the results back into the local project.
A general model can tell you what has been written about your data. This tells you where your data sits.
The bet
The agents that win in science won't be the ones that read the most or run the most trajectories. Those numbers will be commoditized soon — everyone will have them.
They'll be the ones you can put your real data in front of, that are still useful in month nine of a project, and that leave behind something a reviewer, a collaborator, or you-in-eighteen-months can actually follow.
That's what we're building. ARC is included with Heureka Bench, free for macOS and Windows.