How I think about continual learning: a two-agent system
I think the thing that keeps a model improving in production isn't a single learning rule. It's a system. Because different data demands different recipes, I've come to see continual learning as a closed loop with two agents inside it: a light agent that decides what's worth learning from, and an autoresearch agent that figures out how to learn it. This is how I see it.
The take
I see continual learning as a closed-loop system, not a fixed algorithm, because different data demands different recipes. A model in production emits traces; a light decision agent decides whether a batch is worth learning from; and an autoresearch agent runs experiments, recovers from training collapses, and picks the checkpoint that's actually better. Deployment evals gate what ships, then it repeats. I put most of my energy into the autoresearch agent, because as it gets better the rest of the loop gets easier.
Why I frame it as a system
The data a model needs to learn from in production is heterogeneous and changes over time: a batch of new tool-use traces, a shift in user behavior, a rare failure mode, a fresh domain. In my experience the recipe that absorbs one of those cleanly won't be the right one for the next. That's the core reason I don't reach for a single algorithm: there isn't one rule that fits every slice of data.
So instead of betting on a fixed learning rule, the idea is to build a system that, for each new slice of data, finds the right recipe. I frame continual learning as a closed loop with autoresearch at its center.
A deployed model produces production traces. A lightweight agent decides whether a given trace is worth learning from and, if so, triggers autoresearch, which runs a series of educated experiments and trains a candidate checkpoint. Deployment evals then judge whether that checkpoint is genuinely better than what's in production, and only then is it deployed. The freshly deployed model produces new traces, and the loop continues, so the system improves with every interaction. The shift in framing matters: the unit of continual learning is the loop, not the optimizer inside any one run.
Two agents: a cheap gate and a budgeted search
The work splits across two agents on purpose, because deciding to learn and actually learning have very different cost profiles.
The first agent is a light, fast decision-maker. It watches incoming production traces and decides whether a batch is worth learning from. Because it gates the expensive step, it stays cheap and quick, and it needs no context of previous experiments. If it says yes, it hands off to the second stage, where the real budget is spent.
The second stage is autoresearch: a heavier, budgeted search for the right training recipe. Since different data demands different recipes, this agent autonomously runs experiments, recovers from training collapses, and decides which checkpoint is finally worth deploying. That search, run over and over against live production data, is what makes the model continually learn.
Why I focus on the autoresearch agent
Of the two agents, autoresearch is where I put most of the energy, and it's a deliberate bet. It's the hardest and most leveraged piece of the loop: the part that has to reason about data, choose a recipe, run real training, survive things going wrong, and judge the result honestly.
My view is that if the autoresearch agent gets good, the rest of the system gets easier. A strong autoresearch agent makes the decision agent's job simpler: it can afford to pass through more candidate batches, because the search downstream is reliable enough to sort out what's worth keeping. It makes the deployment gate more trustworthy, because the checkpoints arriving at it were chosen by a process that already vetted them. So I start where the leverage is highest and let improvements there flow outward to the rest of the loop.
What the autoresearch agent searches over
If autoresearch is the engine, what are its controls? Training a model that sits on the Pareto frontier of the accuracy-versus-cost curve comes down to two decisions: what data goes into training and which recipe is used. Everything else (provisioning compute, wiring the trainer, logging, checkpointing, scoring) is plumbing the system should hide.
So the autoresearch agent only ever touches those two levers. It proposes a hypothesis, changes the data or the recipe, runs the experiment, reads the score behind an honest test/validation firewall, keeps the win, and discards the regression. The more capable that search becomes, the more of continual learning it quietly takes care of.