Most AI research agents work like a vending machine. You put a question in, a loop runs, an answer drops out, and the thing powers down until the next coin. That shape is fine for a single task. It cannot do the thing that actually makes science hard, which is to keep going for weeks, remember what worked, throw out what didn't, and pick the next question on its own.
I wanted the other shape. So I built ARIA, an autonomous research engine that runs for months at a time. She reads the literature, proposes her own experiments, runs them, checks her own work, files what she learns, and starts again. No prompt. No coin. She does the part of research most people assume still needs a human in the chair.
This is the post I point people at when they ask what ARIA is. It sits alongside a short video of her running and a full case study, and I keep it current. Since I first wrote about her in January, two things happened that are worth the update: the system got a provisional patent, and it got written up as a paper. So this is the first real overview from the far side of both.
Let me show you how she thinks.
The bottleneck was never compute
Everyone points at the GPU. Bigger cluster, bigger model, more compute, more science. That has never matched what research actually feels like.
The slow part is upstream of the hardware. It's reading twenty papers to find the one gap nobody has tested. It's designing the experiment so the result will mean something. It's knowing which of forty plausible ideas is worth a day of expensive compute and which is a dead end dressed up in good vocabulary. The experiment itself often runs in an afternoon. The thinking that decides which experiment to run is where the weeks go.
ARIA is built to automate the thinking, not just the compute.
That reframing is the whole reason she exists. If a machine can generate honest hypotheses, score them against each other, design the test, and only then reach for a GPU, then compute stops being the constraint and starts being the cheap part. Which, as it turns out, it is.
How she works
Underneath the personality is a plain loop with six stages. I'll walk them in order, because the order is the point.
Pool. ARIA keeps a standing pool of research ideas, and they compete. Some she generates herself from fresh literature. Some I hand her. Both kinds land in the same pool and get judged the same way, which means my pet idea has to earn its place next to hers.
Score. Every idea is scored on one honest yardstick, the same function for all of them. Novelty, tractability, evidence, clarity, likely impact. An idea that can't name a testable hypothesis or cites nothing recent scores low and gets culled. The scoring is deliberately strict, because a pool that never says no just grows until it means nothing.
Execute. The highest-scoring idea runs. It runs locally first on cheap hardware, and it only earns a scale-up to real GPUs if the small version shows something. This is the part that keeps the whole thing affordable, and I'll come back to the number, because it surprised me.
Analyze. The result comes back and gets turned into structured signal. Not "it worked," but what moved, by how much, against which baseline, and whether the effect survives a basic sanity check.
Critique. A second AI model, from a different family than the one that ran the work, reviews the result and posts a verdict. The critic is deliberately not the same brain that did the experiment, because a model grading its own homework is exactly as reliable as a person doing the same. If the critique kills the result, that's a good day. A killed result you can trust beats a headline you can't.
Self-heal. Experiments fail. Code throws, a download times out, a run blows past its budget. Instead of halting, ARIA classifies the failure, writes down what it learned, and the recovery re-enters the pool as its own piece of work. She fixes herself and keeps moving.
The flywheel only spins if every stage turns. Generate without culling and the pool rots. Run without a critic and you accumulate confident nonsense.
That's it. Six stages, running around the clock, each one feeding the next.
One kernel, re-pointed
Here is the part I'm proudest of, and it isn't a number. It's that the loop turned out to be portable.
I built the kernel once. Then I pointed it at completely different domains without rewriting the engine, only swapping the ideas, the data, and the tools it's allowed to touch. The same ARIA has now run across three organizations and four research domains: a global pharma R&D setting, an enterprise setting, and a medical-imaging startup. Seven instances off one design.
The system ran for eighteen weeks in one sustained stretch and came back to life on its own 97.8% of the time across more than three hundred separate failures. It left nearly twenty thousand auditable commits behind it, so every decision has a paper trail. A machine that picks itself back up almost every time, and shows its work when you ask, is one you can actually walk away from. That is what convinced me, more than any single benchmark could.
Portability was the thesis, and it held. Build the engine once, re-point it at a new science.
The instance I can talk about most openly is the one aimed at medicine. It's called ARIA-SE, and it runs with a company called SocialEyes on a hard, worthy problem: reading signals of a person's health from a single photograph of the retina. The eye is the one place you can see blood vessels and nerves directly, without cutting anyone open. If a plain retinal camera can flag disease risk, you can screen people in places that will never have a full lab. Rural clinics. Low-resource settings. Anywhere a lab is a plane ride away.
ARIA-SE runs continuously on a borrowed eight-GPU node, and she is busy. Thousands of autonomous sessions, hundreds of experiments, all of it aimed at that screening question. I'm keeping the scientific results themselves for the paper and the peer review they deserve. What I'll say here is the honest shape of it: she is doing real research on a real problem, at a pace no single human on the team could match, and she is doing it while we sleep.
The part I didn't expect
When I started, I assumed the interesting story would be the ideas. The clever hypotheses, the cross-domain leaps, the discoveries.
The interesting story turned out to be how much of her value is in checking her own work.
The critic on a separate model. The honest negatives she keeps instead of quietly dropping, because a clean "this didn't work" saves the team a dead end. The self-healing that treats a failure as information rather than an ending. And most recently, a self-improvement loop: ARIA now proposes small changes to her own code, and those changes only merge if they clear a fixed scope limit and pass a test gate first. She made her first supervised change to herself this way not long ago, behind both of those gates.
The product was never a headline result. It's a research process you can trust because it red-teams itself.
That's the difference between "an AI generated an idea" and something you'd actually stake a decision on. Anyone can generate. The hard, unglamorous, genuinely useful part is a system that can tell you why it believes its own output, and show its work when you ask.
Where she is now
Since the first version of this post, the system crossed two lines it hadn't before.
A provisional patent is filed on the approach. And the whole thing is written up as a paper, with the core engine set to be released openly when that posts. ARIA stopped being only a thing I run in the background and became a thing with a record: a filed invention, a preprint, and a case study you can read end to end.
The original January version of ARIA was a single research agent on one homelab GPU, and its most honest line was a confession: she could design experiments beautifully, but the GPU sat idle, and she hadn't run a single one on real data yet. That gap is closed. She runs experiments now, hundreds of them, on borrowed iron, on a problem that could help people who will never hear her name. The engine that couldn't pull the trigger became one that fires all day and cleans up after itself.
She is, as I write this, running. Nobody is watching the dashboard. That was always the real test.
See it, or go deeper
This post is the overview. If you want to actually watch her work, or read the full build:
Watch ARIA run. A short walkthrough of the live system: the video.
The full case study. The architecture, the metrics, the timeline, in one place: justinhjohnson.com/case/aria.
Built in public. The series on standing her up on a borrowed cluster: Borrowed Iron.
I keep this page current as she evolves. When there's a real update, it goes at the top, and the version it replaces gets summarized below, so the whole story stays in one place.
Previously on ARIA
A running archive of what this post used to say, so the arc stays visible.
January 2026. The Ideation Engine. The first version of ARIA was a single autonomous research agent on one homelab GPU. She kept a pool of around twenty-five competing ideas, scored and refined them across hundreds of sessions, and ran on a dashboard that made every decision visible, down to why one idea scored higher than another. Her honest limitation at the time: she was a brilliant designer of experiments who had not yet run one on real data. The GPU sat idle while she thought. Everything in the version above is the story of closing that gap, re-pointing the engine at real science, and learning that the most valuable thing she does is check her own work.
Inside ARIA is part of an ongoing series on Run Data Run about building autonomous systems you can actually trust. If it was useful, the easiest way to support it is to subscribe and forward it to one person who'd want to see a machine run its own lab. Justin