I have not posted anything new for almost three months. The reason is simple: I was trying a lot of things, and I wanted to learn what was actually useful before writing about it. In that time, models became noticeably better, coding harnesses added persistent Goals, Hermes became capable of more serious work, and I started building a multi-agent orchestrator around AutoResearch. This was not one clean breakthrough. Several small improvements gradually changed how I work.
I need far fewer instructions now
A few months ago, getting an agent to work autonomously required a detailed prompt. When I first wrote about wiring Karpathy's AutoResearch into Claude Code, I had to explain almost every step: read the state, check the previous iteration, change one thing, run the experiment, compare the score, save the result, recover carefully after a failure, and then repeat.
Those instructions were necessary. Without them, the agent could drift from the goal, repeat old work, damage the state, or stop too early. That setup helped me run 100 autonomous iterations, but it took a lot of work. I was not only defining the research problem. I was building guardrails around every iteration so the model would not mess up the loop.
Newer models need much less of that. They are better at following the main goal, reading context, choosing the next step, checking their work, and continuing after a result. I still define the goal and what success means, but I no longer need to describe every small step or predict every possible mistake.
Goals get me most of the result
The Goals feature in coding harnesses reduces the setup even further. For some tasks, I can provide a goal, the important context, and clear success criteria. The harness can then investigate, act, verify, and keep working across turns. In my workflow, that gives me roughly 80 percent of the result of a custom AutoResearch setup with much less effort.
This is not a benchmark. It is a practical estimate from using both approaches. I can get most of the useful autonomous behavior without first writing a large defensive prompt, a control script, and rules for every iteration. A custom AutoResearch loop still matters when I need tighter control over scoring, memory, experiment boundaries, recovery, and iteration structure, but I no longer need to build the complete system for every problem.
The idea behind AutoResearch has not been replaced. Better models and tools have simply made it easier to apply.
I am using Hermes differently
I also spent this time pushing Hermes further. When I wrote about using Hermes for small delegated tasks, I was deliberately conservative. I used it for bounded work I could check quickly: draft a note, inspect an error, summarize a file, or create a first version. That was the useful boundary at the time.
Newer models have moved that boundary. Hermes can now handle longer tasks that require investigation, connected steps, and more judgment. I still give it a clear outcome and review the result, but I do not have to reduce every task to a tiny mechanical instruction first. This lets me use Hermes much closer to its potential. It can take on meaningful pieces of work while I keep control of the goal and the final decision.
Hermes provides the environment for delegation, and the newer models are much better at operating inside it.
The multi-agent experiment
The most interesting thing I am working on now is a multi-agent orchestrator based on AutoResearch. The original system used one agent for the whole loop. It read the state, chose an experiment, ran it, scored the result, saved what happened, and started again. The new orchestrator keeps the main research goal and shared state while several agents handle different parts of the work.
One agent can investigate a hypothesis, another can run an experiment, and a third can challenge the result or check whether an improvement is real. The orchestrator compares their work, updates the shared understanding, and decides what should happen next. The loop is still familiar: decide what is worth trying, delegate the work, evaluate the results, update the shared state, and choose the next step. The difference is that smarter agents can now work on separate parts instead of one heavily instructed agent doing everything in sequence.
I am using Hermes with newer models as part of this system. The goal is not to add agents for the sake of it. I want to see whether specialized agents can explore different directions while one orchestrator keeps the research focused.
This is still experimental. Agents can duplicate work, share the same wrong assumption, or generate more information than the orchestrator can use. More agents cannot fix a vague goal, and a bad score still pushes the whole system in the wrong direction. I do not have a finished general-purpose system yet. That is why I have been testing instead of writing as if the answer were already clear.
Why I am writing now
The last three months were not a pause in the work. They were the work. I tested how much prompting newer models still need. I compared custom AutoResearch with Goals. I pushed Hermes into larger tasks. I explored what changes when several agents share one research goal. The clearest lesson is that I spend much less time telling the model how not to fail. I can spend that time choosing better goals, defining useful success criteria, reviewing results, and designing the larger system around the agents. I still have a lot to learn about multi-agent orchestration. The system will keep changing as I use it, but the direction is now clear enough to write down. That is what I have been doing for the last three months. It is also what I will be writing about next.