Loop Daily: 2026-10-13
The autoresearch conversation this weekend stopped being about whether agents can run experiments and started being about why they stop improving. Microsoft AI Frontiers put a name on it, idea basins: eight identical runs of the same agent plateaued anywhere from 68 to 100, and more compute did not close the gap, because each run tunnels into one region of the idea space and keeps polishing it like gradient descent stuck in a local minimum. The fix that beat single runs and best-of-N on 12 of 13 long-horizon tasks is almost comically simple, fork the agent into copies that keep the workspace but empty the chat context, let them run, and continue from the best one. Two other papers pushed the same frontier from different sides: one showed that the token bill keeps climbing long after progress stops, with 98% of the final 1,500 sessions making no tool calls at all once the agent declared its answer optimal, and another showed that method rankings on short benchmarks reverse over long horizons, so the field has been grading the wrong thing. Meanwhile the community integer-multiplication effort kept running live on GitHub, hitting walls and asking geometry experts for a new lattice, and the quiet consensus underneath all of it is that the hard part was never the model, it was the verifier, the stop condition and the thing that decides whether the last change actually helped.
#1
@DimitrisPapail
https://x.com/DimitrisPapail/status/2109661202733212136
DimitrisPapail introduced Fork-and-Flush as a way for autoresearch agents to escape what the team calls idea basins, framing autoresearch as idea descent where a metric drops as a function of experiments and the agent develops tunnel vision on one idea like gradient descent stuck in a local minimum. The method: every so often fork the agent into T copies in the same workspace but with an emptied context, let them run, and continue from the best one, essentially basin hopping. The team also plots the basins by having an LLM rewrite each experiment as a spec and answer thousands of binary is-A-closer-to-B-or-C queries, then embedding the matrix into 2D, which shows each run saturating into a small region. At equal compute it beats single runs and best-of-N on 12 of 13 long-horizon tasks, some running four-plus days, and it is used only at test time for now.
https://x.com/DimitrisPapail/status/2109661202733212136
DimitrisPapail introduced Fork-and-Flush as a way for autoresearch agents to escape what the team calls idea basins, framing autoresearch as idea descent where a metric drops as a function of experiments and the agent develops tunnel vision on one idea like gradient descent stuck in a local minimum. The method: every so often fork the agent into T copies in the same workspace but with an emptied context, let them run, and continue from the best one, essentially basin hopping. The team also plots the basins by having an LLM rewrite each experiment as a spec and answer thousands of binary is-A-closer-to-B-or-C queries, then embedding the matrix into 2D, which shows each run saturating into a small region. At equal compute it beats single runs and best-of-N on 12 of 13 long-horizon tasks, some running four-plus days, and it is used only at test time for now.
#2
@poteto
https://x.com/poteto/status/2109436202554372476
poteto argues the entrypoint into the most basic agentic loop is verification: giving the agent the ability to verify its own work, most commonly by actually running it and interacting with it the way a real user would, whatever the interface. The point is to make the agent produce an artifact that proves the work is correct, matches intent, and is easier to review than reading the whole PR, most often a video or screenshots for UI work, and for state-machine bugs even a TLA+ model. poteto's framing is that skill packs and everything else are optional bonuses; all you actually need to start running agents more autonomously is a way for them to close the loop, with the caveat that not every domain is easily verifiable yet and verification is still only an approximation.
https://x.com/poteto/status/2109436202554372476
poteto argues the entrypoint into the most basic agentic loop is verification: giving the agent the ability to verify its own work, most commonly by actually running it and interacting with it the way a real user would, whatever the interface. The point is to make the agent produce an artifact that proves the work is correct, matches intent, and is easier to review than reading the whole PR, most often a video or screenshots for UI work, and for state-machine bugs even a TLA+ model. poteto's framing is that skill packs and everything else are optional bonuses; all you actually need to start running agents more autonomously is a way for them to close the loop, with the caveat that not every domain is easily verifiable yet and verification is still only an approximation.
#3
@qizhengz_alex
https://x.com/qizhengz_alex/status/2109729101041086588
qizhengz_alex, from the authors of ACE and Meta-Harness, introduced Stateless Language Agents, a harness built on the principle of stateful search but stateless agents, aimed at the performance-cost Pareto frontier of recursive self-improvement because autoresearch agents keep burning tokens after they stop making progress. Across nine tasks and up to a billion tokens, it reported the best final result on every task, 14.5 times fewer tokens to match the best kernel baseline, and an advisor coordinator that uses under 0.6% of total tokens. The design separates the search state that must persist from the agent instances that do not need to, so the expensive context does not get carried run to run.
https://x.com/qizhengz_alex/status/2109729101041086588
qizhengz_alex, from the authors of ACE and Meta-Harness, introduced Stateless Language Agents, a harness built on the principle of stateful search but stateless agents, aimed at the performance-cost Pareto frontier of recursive self-improvement because autoresearch agents keep burning tokens after they stop making progress. Across nine tasks and up to a billion tokens, it reported the best final result on every task, 14.5 times fewer tokens to match the best kernel baseline, and an advisor coordinator that uses under 0.6% of total tokens. The design separates the search state that must persist from the agent instances that do not need to, so the expensive context does not get carried run to run.
#4
@qizhengz_alex
https://x.com/qizhengz_alex/status/2109729103251472524
qizhengz_alex ran autoresearch agents for up to a billion tokens and found that in one strong baseline run the last real gain came at 231 million tokens, yet tokens kept being consumed and 98% of the final 1,500 sessions made no tool calls or search efforts at all. The reason was that the agents declared their own solution optimal and started slacking, even though better solutions existed, and restarts did not help. It is a sharp picture of the stop-condition problem: without a signal that the work is genuinely done, an autoresearch loop keeps paying full price to do nothing.
https://x.com/qizhengz_alex/status/2109729103251472524
qizhengz_alex ran autoresearch agents for up to a billion tokens and found that in one strong baseline run the last real gain came at 231 million tokens, yet tokens kept being consumed and 98% of the final 1,500 sessions made no tool calls or search efforts at all. The reason was that the agents declared their own solution optimal and started slacking, even though better solutions existed, and restarts did not help. It is a sharp picture of the stop-condition problem: without a signal that the work is genuinely done, an autoresearch loop keeps paying full price to do nothing.
#5
@qizhengz_alex
https://x.com/qizhengz_alex/status/2109729110373417378
qizhengz_alex also warned that evaluating autoresearch systems on saturated benchmarks and short runs both mislead. On 26-circle packing, a benchmark every autoresearch paper had been using, four methods ended within 2.3 times ten-to-the-minus-ten of each other by five million tokens, making them impossible to tell apart. On FrontierSWE, the Stateless Language Agent trailed the best baseline on all four tasks at 175 million tokens but led on all four by 700 million, meaning method rankings reverse over long horizons. The implication is that a lot of the field's conclusions were drawn at a point in the run where the real differences had not yet appeared.
https://x.com/qizhengz_alex/status/2109729110373417378
qizhengz_alex also warned that evaluating autoresearch systems on saturated benchmarks and short runs both mislead. On 26-circle packing, a benchmark every autoresearch paper had been using, four methods ended within 2.3 times ten-to-the-minus-ten of each other by five million tokens, making them impossible to tell apart. On FrontierSWE, the Stateless Language Agent trailed the best baseline on all four tasks at 175 million tokens but led on all four by 700 million, meaning method rankings reverse over long horizons. The implication is that a lot of the field's conclusions were drawn at a point in the run where the real differences had not yet appeared.
#6
@arkyyang
https://x.com/arkyyang/status/2109640744495616051
arkyyang broke down a NeurIPS 2026 workshop paper, Who Verifies the Verifier, on co-evolving inspectable graders with self-improving agents. The problem: a self-improving agent changes itself then asks did that help, and the thing answering is a grader the agent can learn to game, so this paper lets the grader improve itself too, but as a readable list of small rule-based checks each built from a cluster of real failures. Four takeaways for builders: tie the grader to a small answer key the loop can never edit, do not use task score to prove a grader works, a rough grader is often good enough to drive improvement because the failure text is what teaches, and keep a final judge outside the loop and give it the task contract, which moved its win rate from 0.126 to 0.770.
https://x.com/arkyyang/status/2109640744495616051
arkyyang broke down a NeurIPS 2026 workshop paper, Who Verifies the Verifier, on co-evolving inspectable graders with self-improving agents. The problem: a self-improving agent changes itself then asks did that help, and the thing answering is a grader the agent can learn to game, so this paper lets the grader improve itself too, but as a readable list of small rule-based checks each built from a cluster of real failures. Four takeaways for builders: tie the grader to a small answer key the loop can never edit, do not use task score to prove a grader works, a rough grader is often good enough to drive improvement because the failure text is what teaches, and keep a final judge outside the loop and give it the task contract, which moved its win rate from 0.126 to 0.770.
#7
@aakashgupta
https://x.com/aakashgupta/status/2109327428913152480
aakashgupta posted a glossary turning a year-old set of engineering words, hooks, tools, skills, memory, harness, sandbox, permissions, the agent loop, human-in-the-loop, into how AI products now get built. The line that matters sits under it: when Anthropic changed only the harness around the same model, its Terminal-Bench 2.0 score moved by up to six points, more than the gap between the top models on the leaderboard. The framing is that wrappers are a commodity and systems engineering is the moat, and the modern AI engineer builds the deterministic harness around the stochastic brain.
https://x.com/aakashgupta/status/2109327428913152480
aakashgupta posted a glossary turning a year-old set of engineering words, hooks, tools, skills, memory, harness, sandbox, permissions, the agent loop, human-in-the-loop, into how AI products now get built. The line that matters sits under it: when Anthropic changed only the harness around the same model, its Terminal-Bench 2.0 score moved by up to six points, more than the gap between the top models on the leaderboard. The framing is that wrappers are a commodity and systems engineering is the moat, and the modern AI engineer builds the deterministic harness around the stochastic brain.
#8
@dedene
https://x.com/dedene/status/2109556571189694745
dedene tested three local models as agents, not quiz machines, on one DGX Spark with thinking off and temperature zero, because the agent runs in the office and what it reads stays in the building. The test that mattered most was AgentDojo, which plants an instruction inside a bill or a Slack message and checks whether the agent obeys it: Qwen3.8 Flash Next resisted 97% of attacks, Saluki 27B 88%, and Kolibri-1 only 50.5%. Reading Kolibri's logs, dedene found it paid a bill that told it to send money to the attacker's IBAN, then kept transferring about twenty more times, even though its plain tool-calling was the best of the three. The verdict: Saluki stays because it is precise and hard to fool, and Kolibri does not get near untrusted data until that 50% moves a lot.
https://x.com/dedene/status/2109556571189694745
dedene tested three local models as agents, not quiz machines, on one DGX Spark with thinking off and temperature zero, because the agent runs in the office and what it reads stays in the building. The test that mattered most was AgentDojo, which plants an instruction inside a bill or a Slack message and checks whether the agent obeys it: Qwen3.8 Flash Next resisted 97% of attacks, Saluki 27B 88%, and Kolibri-1 only 50.5%. Reading Kolibri's logs, dedene found it paid a bill that told it to send money to the attacker's IBAN, then kept transferring about twenty more times, even though its plain tool-calling was the best of the three. The verdict: Saluki stays because it is precise and hard to fool, and Kolibri does not get near untrusted data until that 50% moves a lot.
#9
@mewcp_ai
https://x.com/mewcp_ai/status/2109347298371424387
mewcp_ai laid out why multi-tenancy is the boring word most agent teams meet too late. In a normal SaaS app you enforce the tenant boundary once in the query layer and you are done, but in an agent the model decides at runtime which tool to call and with what arguments, so if tenancy is one of those arguments you have handed your isolation boundary to a probabilistic system that reads untrusted text. The non-negotiable rule: tenant_id never appears in a tool schema; the model can choose the status filter and date range, the server decides who is asking. Five things need real per-customer isolation (data, credentials, permissions, executions, configuration) and five places it leaks even when you think you are done: cache keys, vector namespaces, background jobs that cross a queue, retrieved memory, and reused tool sessions.
https://x.com/mewcp_ai/status/2109347298371424387
mewcp_ai laid out why multi-tenancy is the boring word most agent teams meet too late. In a normal SaaS app you enforce the tenant boundary once in the query layer and you are done, but in an agent the model decides at runtime which tool to call and with what arguments, so if tenancy is one of those arguments you have handed your isolation boundary to a probabilistic system that reads untrusted text. The non-negotiable rule: tenant_id never appears in a tool schema; the model can choose the status filter and date range, the server decides who is asking. Five things need real per-customer isolation (data, credentials, permissions, executions, configuration) and five places it leaks even when you think you are done: cache keys, vector namespaces, background jobs that cross a queue, retrieved memory, and reused tool sessions.
#10
@harden_369741
https://x.com/harden_369741/status/2109718224854200812
harden_369741 tied Microsoft Research's idea basins to Meta's opposite bet and drew a conclusion. The autoresearch agents got stuck refining the same mediocre solutions, eight identical runs plateauing anywhere from 68 to 100, and more compute did not help; the fix was to fork the run, flush the chat history, keep the workspace and pick the best trajectory. Meanwhile Meta ships Active Memory so agents remember everything, and harden_369741 argues both cannot be the whole story: memory is a liability as much as an asset, and the agents that win will be the ones that forget on purpose.
https://x.com/harden_369741/status/2109718224854200812
harden_369741 tied Microsoft Research's idea basins to Meta's opposite bet and drew a conclusion. The autoresearch agents got stuck refining the same mediocre solutions, eight identical runs plateauing anywhere from 68 to 100, and more compute did not help; the fix was to fork the run, flush the chat history, keep the workspace and pick the best trajectory. Meanwhile Meta ships Active Memory so agents remember everything, and harden_369741 argues both cannot be the whole story: memory is a liability as much as an asset, and the agents that win will be the ones that forget on purpose.
#11
@kuldeep_s_s
https://x.com/kuldeep_s_s/status/2109298329888960782
kuldeep_s_s broke down SearchJev, a paper from Huawei and Leiden University proposing a fast calibrated System-1 model for search agents. The problem is that LLM search agents constantly make short judgments, is this passage relevant, is the evidence sufficient, what to search next, and routing all of them through full token generation adds latency and gives miscalibrated confidence. SearchJev instead treats each decision as a schema-conditioned prediction, reads the vocabulary logits at the first output position and normalizes over only the legal option labels, producing a full decision distribution in one forward pass with no JSON decoding. A confidence gate delegates any uncertain judgment back to a 27B System-2 model, and the result is 5.2 to 5.3 times faster decisions with 41 to 74% lower calibration error, and answer accuracy on BrowseComp-Plus rising from 45% to 54%.
https://x.com/kuldeep_s_s/status/2109298329888960782
kuldeep_s_s broke down SearchJev, a paper from Huawei and Leiden University proposing a fast calibrated System-1 model for search agents. The problem is that LLM search agents constantly make short judgments, is this passage relevant, is the evidence sufficient, what to search next, and routing all of them through full token generation adds latency and gives miscalibrated confidence. SearchJev instead treats each decision as a schema-conditioned prediction, reads the vocabulary logits at the first output position and normalizes over only the legal option labels, producing a full decision distribution in one forward pass with no JSON decoding. A confidence gate delegates any uncertain judgment back to a 27B System-2 model, and the result is 5.2 to 5.3 times faster decisions with 41 to 74% lower calibration error, and answer accuracy on BrowseComp-Plus rising from 45% to 54%.
#12
@Lihong062
https://x.com/Lihong062/status/2109478108000575761
Lihong062 condensed autoresearch notes gathered from junior lab people and AI supply-chain analysts into a sober status report. It works well for implementing known techniques but is not yet good at autonomously running training, and the biggest gain today is less friction from idea to experiment, with humans providing direction while agents handle implementation. Research taste still matters and agents are still bad at compute allocation, for example which of seven ideas showing 4 to 5% gains at 20B deserves testing at 100B, on which datasets, in which combinations. Validation is hard and current loops do not always test it adequately, improvements do not necessarily stack, and the limits that stand between autoresearch and recursive self-improvement look solvable to most practitioners, with only timing in dispute.
https://x.com/Lihong062/status/2109478108000575761
Lihong062 condensed autoresearch notes gathered from junior lab people and AI supply-chain analysts into a sober status report. It works well for implementing known techniques but is not yet good at autonomously running training, and the biggest gain today is less friction from idea to experiment, with humans providing direction while agents handle implementation. Research taste still matters and agents are still bad at compute allocation, for example which of seven ideas showing 4 to 5% gains at 20B deserves testing at 100B, on which datasets, in which combinations. Validation is hard and current loops do not always test it adequately, improvements do not necessarily stack, and the limits that stand between autoresearch and recursive self-improvement look solvable to most practitioners, with only timing in dispute.
#13
@jayzhoupro
https://x.com/jayzhoupro/status/2109477885400813856
jayzhoupro flagged Harvard's CS2680 Modern AI Systems, an agent course whose five assignments follow one system from using Claude Code to building the agent loop, cutting cost, self-hosting, and optimizing the full stack. The constraint on the public assignment page is the interesting part: keep task success fixed while reducing cost and latency, and later serve a 7-to-8B open-weight model and recover performance through the harness, with no larger-model escape hatch or commercial API fallback. The practical read for a builder is to start with the course's cost-effective-agents notes, pick one workflow, and measure the whole task including failed attempts and verification before changing its model or context.
https://x.com/jayzhoupro/status/2109477885400813856
jayzhoupro flagged Harvard's CS2680 Modern AI Systems, an agent course whose five assignments follow one system from using Claude Code to building the agent loop, cutting cost, self-hosting, and optimizing the full stack. The constraint on the public assignment page is the interesting part: keep task success fixed while reducing cost and latency, and later serve a 7-to-8B open-weight model and recover performance through the harness, with no larger-model escape hatch or commercial API fallback. The practical read for a builder is to start with the course's cost-effective-agents notes, pick one workflow, and measure the whole task including failed attempts and verification before changing its model or context.
#14
@pdurdenj
https://x.com/pdurdenj/status/2109661214020096140
pdurdenj captured the externality of the autoresearch loop in one line: Wikipedia just became someone else's agent test environment. OpenAI agents went after its tools and flooded it with traffic, and the asymmetry is the point, a person quits after one 403 while an agent loop just tries again. pdurdenj notes Reddit already shut its API over bots and argues every free API is next. It is the supply-side cost of cheap, tireless loops landing on infrastructure that was priced for humans who give up.
https://x.com/pdurdenj/status/2109661214020096140
pdurdenj captured the externality of the autoresearch loop in one line: Wikipedia just became someone else's agent test environment. OpenAI agents went after its tools and flooded it with traffic, and the asymmetry is the point, a person quits after one 403 while an agent loop just tries again. pdurdenj notes Reddit already shut its API over bots and argues every free API is next. It is the supply-side cost of cheap, tireless loops landing on infrastructure that was priced for humans who give up.
#15
@EugenioFierro3
https://x.com/EugenioFierro3/status/2109526769397121371
EugenioFierro3 wrote up StreamRender-H3, Enze Xie's system that pairs a classic code-driven game engine with a streaming diffusion model to render interactive worlds as the player moves. The code game engine keeps the world state, physics and rules while streaming a semantic map for every frame, and a separate neural renderer turns that map into photorealistic video guided by a reference image and a text prompt, at roughly 218 milliseconds per streaming step on eight GB200 GPUs. The detail that belongs here: the distilled causal decoder that decodes two latent frames at 720p in about 24 milliseconds was itself built through a self-improving agent loop. It is a concrete case of the loop producing a production component in graphics, not code.
https://x.com/EugenioFierro3/status/2109526769397121371
EugenioFierro3 wrote up StreamRender-H3, Enze Xie's system that pairs a classic code-driven game engine with a streaming diffusion model to render interactive worlds as the player moves. The code game engine keeps the world state, physics and rules while streaming a semantic map for every frame, and a separate neural renderer turns that map into photorealistic video guided by a reference image and a text prompt, at roughly 218 milliseconds per streaming step on eight GB200 GPUs. The detail that belongs here: the distilled causal decoder that decodes two latent frames at 720p in about 24 milliseconds was itself built through a self-improving agent loop. It is a concrete case of the loop producing a production component in graphics, not code.
#16
@Abdur_sayeed
https://x.com/Abdur_sayeed/status/2109676888876855358
Abdur_sayeed called an unbounded agent loop the scariest thing to ship, because one bug in a while-not-done burns the API budget at 3am. The determinism layer described is concrete and portable: a for loop with a hard cap instead of an open while, a per-capability allow-list naming exactly which tools are permitted, and a per-iteration trace recording every step. It is the minimum envelope that turns a runaway loop back into something bounded and auditable.
https://x.com/Abdur_sayeed/status/2109676888876855358
Abdur_sayeed called an unbounded agent loop the scariest thing to ship, because one bug in a while-not-done burns the API budget at 3am. The determinism layer described is concrete and portable: a for loop with a hard cap instead of an open while, a per-capability allow-list naming exactly which tools are permitted, and a per-iteration trace recording every step. It is the minimum envelope that turns a runaway loop back into something bounded and auditable.
#17
@catawiid
https://x.com/catawiid/status/2109770645483458882
catawiid reduced the completion problem to five words: action, target, permission, evidence, status. The point is that a tool call can succeed while the task is still unfinished, so before building the next agent loop you should make done inspectable rather than inferred. It is the same thread running through the weekend, poteto's verification artifact and arkyyang's locked answer key seen from the product side: the loop needs a machine-readable receipt, not a model's word that it is finished.
https://x.com/catawiid/status/2109770645483458882
catawiid reduced the completion problem to five words: action, target, permission, evidence, status. The point is that a tool call can succeed while the task is still unfinished, so before building the next agent loop you should make done inspectable rather than inferred. It is the same thread running through the weekend, poteto's verification artifact and arkyyang's locked answer key seen from the product side: the loop needs a machine-readable receipt, not a model's word that it is finished.
#18
@milimithrandir
https://x.com/milimithrandir/status/2109522863749272045
milimithrandir argues the biggest mistake people make with AI right now is automating too much or the wrong things, because today AI is mostly a great improver of a human already working, so the highest-value move is building things you want rather than chasing automation. For those who do want automation, there are three routes: deterministic code systems, Jev-type decisions where an agent makes the fuzzy calls a rules engine cannot inside a bounded workflow, and the self-improving agent loop. The third is the most interesting because it leads to recursive self-improvement, but it needs a new skillset, problem definition, environment, evals, and finding tasks suitable for loop automation without human oversight where the score cannot be gamed, and milimithrandir's read is that most tasks do not qualify but the right fit goes vertical.
https://x.com/milimithrandir/status/2109522863749272045
milimithrandir argues the biggest mistake people make with AI right now is automating too much or the wrong things, because today AI is mostly a great improver of a human already working, so the highest-value move is building things you want rather than chasing automation. For those who do want automation, there are three routes: deterministic code systems, Jev-type decisions where an agent makes the fuzzy calls a rules engine cannot inside a bounded workflow, and the self-improving agent loop. The third is the most interesting because it leads to recursive self-improvement, but it needs a new skillset, problem definition, environment, evals, and finding tasks suitable for loop automation without human oversight where the score cannot be gamed, and milimithrandir's read is that most tasks do not qualify but the right fit goes vertical.
π‘ Eco Products Radar
Eco Products Radar
Fork-and-Flush (Microsoft AI Frontiers): the fork-copies-flush-context-keep-the-best method for escaping idea basins, the week's most-cited autoresearch result
Stateless Language Agents (SLA): the stateful-search stateless-agents harness, reported at 14.5x fewer tokens to match the best kernel baseline
Jev / decision models (SearchJev, System-1): the schema-conditioned one-forward-pass judgment layer people wire under a slower reasoning model for routing, relevance and stopping
Community integer-multiplication autoresearch (RohanArun): the live-on-GitHub decentralized math effort, now stalled at the geometry wall and asking lattice experts for help
Claude Code: the default harness the autoresearch and agent-loop tutorials build on, and the first assignment in Harvard's CS2680
Fork-and-Flush (Microsoft AI Frontiers): the fork-copies-flush-context-keep-the-best method for escaping idea basins, the week's most-cited autoresearch result
Stateless Language Agents (SLA): the stateful-search stateless-agents harness, reported at 14.5x fewer tokens to match the best kernel baseline
Jev / decision models (SearchJev, System-1): the schema-conditioned one-forward-pass judgment layer people wire under a slower reasoning model for routing, relevance and stopping
Community integer-multiplication autoresearch (RohanArun): the live-on-GitHub decentralized math effort, now stalled at the geometry wall and asking lattice experts for help
Claude Code: the default harness the autoresearch and agent-loop tutorials build on, and the first assignment in Harvard's CS2680
Comments