Doodling in Autoresearch

1. Memory Structure with Knowledge Crystallization

Coding agents like Codex and Claude Code can already reason through extremely hard problems. In long-horizon autoresearch, however, the experiments they run quickly produce far more than their context windows can hold. An experiment is not merely a score: it records a direction worth trying, the assumptions behind it, and usually some reflection on the result and what to do next. As thousands of these accumulate, the agent’s only option is to compact its context, summarizing what it has done so far and continuing from it. I don’t think relying on the agent’s own memory is the right way to build stronger autoresearch systems. It doesn’t seem promising to keep our useful knowledge inside the agent, where it suffers from round after round of compaction. Moreover, after a day, no one can actually see what the agent has learned, let alone evaluate it.

The natural fix is to move research state out of the agent and into the harness. Agents then become contributors: they read the shared state, run experiments, and write back what they found. However, this only relocates the problem. The harness now holds thousands of experiment records, and the important question becomes how those records should be organized, and how a growing archive of experiments can be crystallized into useful knowledge.

Two recent works offer memory structures I find interesting. SwarmResearch (Virk et al., 2026) keeps a population of candidate solutions, each in its own Git branch and worktree. Each branch accumulates its own findings, and agents contribute to these branches under the guidance of an orchestrator. Agora (Y. Zhang et al., 2026) organizes hypotheses, results, insights, and verifications into a Git-backed DAG, where the edges record how one finding builds on another. This lets any result be traced back to the hypothesis that motivated it and the evidence behind it. Git branches, as in SwarmResearch, are good at maintaining diverse ideas and combining them, while a directed graph like Agora’s keeps track of how ideas flow: where each one came from and how it developed.

However, I think neither structure, nor most current autoresearch systems, answers one question. The findings they store all stay at the micro level. What I want is something I think of as knowledge crystallization: observations gradually become general, reusable lessons, while unimportant attempts fade away instead of lingering as branches. Why care about crystallization? A structure that only accumulates leaves the work of generalizing to the agents. They have to dig the useful lessons out of a huge pile of records before they can improve, which is a heavy burden. A structure that summarizes too early has the opposite problem: an unverified guess can harden into a belief that misleads the agent over time.

Given these problems, can we even optimize for the best memory structure?

I think it is possible. Librarian Agents (Singh et al., 2026), a recent work I find especially interesting, trains a builder agent to reorganize raw documents into a hierarchical workspace, and optimizes the builder for how well a downstream answering agent performs on top of that workspace. I think this carries an insight for autoresearch systems: there may not be one best memory structure, but different best structures for different tasks, and they could be learned rather than designed, or, from an even crazier perspective, they could keep evolving. I believe there is a lot to explore here, especially in optimizing the container that turns experiments into crystals.

2. Context Construction and Orchestration

Once research state lives in the harness, another nontrivial question appears: what should each agent actually see? Even if we have good memory structures, this does not mean we need to show the agent everything, and this leads to the problem of context construction. What context an agent should get depends on its role in the larger autoresearch system. SwarmResearch (Virk et al., 2026) is a good example. Its Shepherd, whose job is to maintain the general direction of research, sees the global history: summaries of every search agent’s attempts and their scores. It uses this history to pick the parent branch and agent type for each new agent. Explorer agents, whose job is to discover new ideas, start with a fresh context window, seeing only their own worktree and a short prompt from the Shepherd, so they are less anchored to earlier work and more likely to try something new. Optimizer agents, whose job is to do more refinements and possible increments on existing solutions, fork their parent’s conversation and inherit a detailed log of what worked and what failed. This gives them enough context for several rounds of careful refinement. Search agents are not allowed to look at other branches at all, because, the authors argue, shared memory pulls every agent toward the current best solution.

Stateless Language Agents (SLA; Q. Zhang et al., 2026) follows the same spirit of context construction. The Advisor sees structured evidence across all search directions, and each Worker sees only its assignment, its current candidate, and local feedback. The Advisor needs to steer the research direction, so it needs evidence from across the whole search, while a Worker needs to do as well as it can in its assigned direction, and any irrelevant history can distract its thinking.

Another, more extreme form of context construction is simply forgetting things. Why do that? Because it can encourage diversity and fully leverage coding agents’ abilities, since an agent’s past history can easily anchor its next design. Scaling Discovery Requires Forgetting (Tan et al., 2026) finds that the common ways of scaling autoresearch, such as longer runs, more parallel agents, and agents that build on each other’s candidates, all eventually plateau, because agents stick to their past attempts and make fewer and smaller edits over time. Having a team of communicating agents periodically discard every agent’s session and the candidate history, then restart from the best candidate found so far, works well: under the same budget, it beats parallel agents by up to 15% and a single agent by up to 39%. This suggests that what an agent is allowed to know or remember heavily affects its performance in completing its tasks in autoresearch systems.

Since context construction depends heavily on the roles coding agents play inside the autoresearch system, the next question arises: how should we orchestrate agents, and who should do what? One option is a centralized design, like the Advisor in Stateless Language Agents, which turns global evidence into concrete assignments. Decentralized designs avoid a single coordinator altogether, because the whole system can easily be bottlenecked by the Advisor’s choices. CORAL’s agents (Qu et al., 2026) coordinate indirectly through shared memory. DeLM (Mao et al., 2026) goes further, replacing the main agent with a shared context and a task queue: agents claim tasks asynchronously, write back compact verified updates, and when the queue runs dry, whoever finished last decides what to add next. But decentralized systems have weaknesses too. Coordination is relatively hard, and duplicated effort is very likely to creep in.

Now picture our company of agents as your own AI startup, with everyone working on a research project together. Even we humans may not have the best way to cooperate, so how can we expect agents to figure it out?

Just as different companies organize themselves differently, and different kinds of work call for different kinds of cooperation, maybe the right collaboration pattern is not fixed at all. AI agents are also very smart, so why not turn orchestration into an optimization objective? We could let the agents choose their own way of cooperating, perhaps by following whoever is the smartest. With fixed compute, the number of agents working together might also vary from task to task. Learning Self-Orchestration in Decentralized Agent Swarms (Xu et al., 2026) already reflects some of this idea: in market-based post-training, each agent learns both how to act and how much to bid for a turn, and orchestration emerges from the bidding without a central coordinator.

Even with ideal context, the agents’ organization would keep changing. Each time, an agent’s task would come with the right context constructed from the shared memory bank, the “company assets,” and perhaps smarter agents would get promoted, with access to more information. I think this is one of the hardest parts of autoresearch: getting context construction and orchestration right together. The former lets each agent know what it should do to reach its full potential; the latter makes $\sum _{i=1}^{n}1\gg n$ (the whole being worth more than its parts). And memory structure is the foundation of both. After all, it is the knowledge base of the company.

3. Making Evaluation Faster and Cheaper

One of the most important things for autoresearch systems is iteration speed: how fast you can get results and feedback from the system. In many scenarios, this iteration speed is bottlenecked by the cost of evaluation. Some evaluations in biology or chemistry discovery can take days or cost too much for AI to test a lot of ideas.

The recent work DuoDiscover (Agarwal et al., 2026) attacks this directly. Instead of treating the evaluator as fixed, it discovers two things together: the optimization targets worth working on, and cheap, executable yardsticks that can score candidates quickly. Expensive full evaluations still happen, but they play two roles. They confirm that an improvement is real, and they check whether each yardstick is still telling the truth. This suggests that we can use a small number of “golden” evaluations to develop cheap rewards to optimize against, and to keep those rewards pointing in the right direction. The cheap reward does not have to be perfect. It only needs to distinguish candidates well enough to decide which ones deserve a real evaluation.

Maybe the feedback mechanism itself should be learned and become part of the system’s memory. A proxy is a piece of knowledge, just like a lesson about which direction works: it was validated under certain conditions, and it can drift over time. The system can also learn which proxies were useful and how to construct good ones. An even crazier thought: once the system masters the task itself, can it propose harder proxies, or even new objectives, based on what it has learned?

Closing Thoughts

Back to our company of agents. Memory holds its company assets, context construction decides what each employee sees, orchestration decides who works on what, and evaluation decides how quickly anyone finds out whether an idea worked. I have discussed them one at a time, but they are not separate. Evaluation results flow back into memory, memory determines what context each agent can be given, and that context shapes how the work should be divided.

Today, most of these pieces are designed by hand and tuned separately: a memory format someone chose, a prompt that decides what a worker sees, a fixed advisor-worker split, a proxy that is trusted until it breaks. But I believe the optimal design for every piece differs from task to task, and it is interesting to think about handing these design choices to the agents themselves and letting them optimize themselves.

And I think some of these design choices extend far beyond autoresearch: they generalize to anything that involves feedback loops and agent cooperation. Maybe we will have an agent company after all?

References

Agarwal, S., Gupta, A., Heddes, M., Soylu, D., Meng, R., Kon, P. T. J., et al. (2026). DuoDiscover: Scaling Autonomous Discovery Beyond the Evaluation Bottleneck. arXiv:2610.17184.

Cai, Z., Ziakas, C., Kontonis, V., Pearce, T., Sen, S., Krishnamurthy, A., et al. (2026). Fork-and-Flush: Escaping Idea Basins in Autoresearch Agents. arXiv:2610.07447.

Mao, Y., Gu, J., Chauhan, A., Zhang, Q., Kang, H., & Mirhoseini, A. (2026). Decentralized Multi-Agent Systems with Shared Context. arXiv:2606.10662.

Qu, A., Zheng, H., Zhou, Z., Yan, Y., Tang, Y., Ong, S. Y., et al. (2026). CORAL: Towards Autonomous Multi-Agent Evolution for Open-Ended Discovery. Conference on Language Modeling (COLM). arXiv:2604.01658.

Singh, A., Zhang, T., Lee, Y., Nair, R. S., Kumar, A., & Finn, C. (2026). Librarian Agents: Training LLMs to Curate Long-Context Workspaces that Anticipate Future Queries. arXiv:2610.22273.

Tan, S., Zhou, B., Agrawal, L. A., Zhang, J., Chen, Y., Mang, Q., et al. (2026). Scaling Discovery Requires Forgetting. arXiv:2610.20563.

Virk, Y., Edds, Z., Xia, C. S., & Zhang, L. (2026). SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery. arXiv:2607.02807.

Xu, G., Qi, Z., Kiruga, A., Lakkaraju, H., & Du, Y. (2026). Learning Self-Orchestration in Decentralized Agent Swarms. arXiv:2610.22322.

Zhang, Q., Ji, C., Sun, I., Li, Y., Upasani, S., Ruan, S., et al. (2026). Stateless Language Agents: Scaling Long-Horizon Automated Research. arXiv:2610.07625.

Zhang, Y., Zou, Y., Zhang, S., Hu, J., Zhang, H., Xu, B., et al. (2026). Agora: Git as Shared Memory for Collective AutoResearch. arXiv:2609.18094.