Loop Daily: September 1, 2026
Autoresearch stopped being a Karpathy demo this week and started showing up as a thing people leave running overnight. The pattern is stabilizing into a shape everyone now recognizes: give an agent a goal, a metric, and a sandbox, let it propose, run, measure, keep the wins and revert the losses, then repeat while you sleep. What's new isn't the loop, it's where people are pointing it, at their own coding harness's memory policy, at CUDA kernels and shaders for a week straight, at proximity-gap math conjectures, at physical robots that 3D-print their own parts. And the sharpest voices this week all converge on one warning: a loop without a verifier that can name what failed is just theatre. Here's what's actually running.
#1
@rochecompaan
https://x.com/rochecompaan/status/2093721424120664449
Maybe the most meta use of the week. He's experimenting with a radical context policy for coding agents: keep the working context tiny, aggressively delete old conversation, keep full history outside the window and give the agent tools to page exact pieces back in. Then he took it one level up, using pi-autoresearch to optimize the context policy itself, giving another agent an experimental environment to discover better ways to structure the first agent's working memory. He hasn't found anyone else applying an autoresearch-style optimization loop specifically to context management, and he's asking.
https://x.com/rochecompaan/status/2093721424120664449
Maybe the most meta use of the week. He's experimenting with a radical context policy for coding agents: keep the working context tiny, aggressively delete old conversation, keep full history outside the window and give the agent tools to page exact pieces back in. Then he took it one level up, using pi-autoresearch to optimize the context policy itself, giving another agent an experimental environment to discover better ways to structure the first agent's working memory. He hasn't found anyone else applying an autoresearch-style optimization loop specifically to context management, and he's asking.
#2
@pwnies
https://x.com/pwnies/status/2093494257105379569
A concrete, shipped autoresearch loop called Speedlab that speeds up your websites. It pulls a list of common speed improvements, tests them against your site, and keeps the successful candidates. He describes it as very fun to watch a site slowly get faster on its own. This is the loop stripped to its cleanest form: measurable target, a pool of candidate moves, keep what works.
https://x.com/pwnies/status/2093494257105379569
A concrete, shipped autoresearch loop called Speedlab that speeds up your websites. It pulls a list of common speed improvements, tests them against your site, and keeps the successful candidates. He describes it as very fun to watch a site slowly get faster on its own. This is the loop stripped to its cleanest form: measurable target, a pool of candidate moves, keep what works.
#3
@stretchcloud
https://x.com/stretchcloud/status/2094297380409811113
OpenResearch CLI runs the entire autoresearch loop locally, using Claude Code, Codex, and OpenCode in parallel git worktrees with your data staying on your machine. Give it a goal and it handles literature review, experiment analysis, and synthesis, with agents isolated in worktrees so their work doesn't collide. He built Campfire as the general-purpose coordination layer on top: run five agent CLIs side by side in one browser tab, majority-rules permission voting, session replay, agent races across worktrees, shared semantic memory. The point he keeps making is that the actual agentic work takes seconds while coordination between agents takes minutes, so the coordination layer is the real product.
https://x.com/stretchcloud/status/2094297380409811113
OpenResearch CLI runs the entire autoresearch loop locally, using Claude Code, Codex, and OpenCode in parallel git worktrees with your data staying on your machine. Give it a goal and it handles literature review, experiment analysis, and synthesis, with agents isolated in worktrees so their work doesn't collide. He built Campfire as the general-purpose coordination layer on top: run five agent CLIs side by side in one browser tab, majority-rules permission voting, session replay, agent races across worktrees, shared semantic memory. The point he keeps making is that the actual agentic work takes seconds while coordination between agents takes minutes, so the coordination layer is the real product.
#4
@rel_zeta_tech
https://x.com/rel_zeta_tech/status/2094001764043264330
A genuinely striking non-coding result. Watching the autoresearch project attack the proximity gaps conjecture, he says for the first time he's seeing indisputably interesting, novel techniques being LLM-generated in a mathematical question he actually cared about. It raises a real question he poses openly: when LLMs rapidly discover new math results, will we still need a crowd of human mathematicians to make sense of them, or is it enough that they're formally verified in Lean?
https://x.com/rel_zeta_tech/status/2094001764043264330
A genuinely striking non-coding result. Watching the autoresearch project attack the proximity gaps conjecture, he says for the first time he's seeing indisputably interesting, novel techniques being LLM-generated in a mathematical question he actually cared about. It raises a real question he poses openly: when LLMs rapidly discover new math results, will we still need a crowd of human mathematicians to make sense of them, or is it enough that they're formally verified in Lean?
#5
@theblazehen
https://x.com/theblazehen/status/2094338933643424161
Real overnight-run territory. He's had autoresearch working on shaders plus Vulkan and CUDA kernels for a full week of wall-clock time with no unrecoverable stall, driven through omp's /autoresearch mode with an external grader service bolted on. In a follow-up he notes he's on his last autoresearch run before switching to manual, calling it a decent start. This is the unglamorous reality of long-horizon loops: they mostly hold, and you eventually take the wheel back to finish.
https://x.com/theblazehen/status/2094338933643424161
Real overnight-run territory. He's had autoresearch working on shaders plus Vulkan and CUDA kernels for a full week of wall-clock time with no unrecoverable stall, driven through omp's /autoresearch mode with an external grader service bolted on. In a follow-up he notes he's on his last autoresearch run before switching to manual, calling it a decent start. This is the unglamorous reality of long-horizon loops: they mostly hold, and you eventually take the wheel back to finish.
#6
@EyalToledano
https://x.com/EyalToledano/status/2093744128303481044
Planning a centralized autoresearch pool inside his engine's TUI, so anyone can put their hardware to work optimizing the engine against a shared experiment pool. The design goal is to allow non-code contributions while still being open to PRs, essentially turning autoresearch into a communal compute effort rather than a solo overnight job. The engine release is imminent.
https://x.com/EyalToledano/status/2093744128303481044
Planning a centralized autoresearch pool inside his engine's TUI, so anyone can put their hardware to work optimizing the engine against a shared experiment pool. The design goal is to allow non-code contributions while still being open to PRs, essentially turning autoresearch into a communal compute effort rather than a solo overnight job. The engine release is imminent.
#7
@tonbistudio
https://x.com/tonbistudio/status/2094435654125883417
A hardware-grounded benchmark: which local model that fits on a DGX Spark performs autoresearch the best. The contenders are Ornith 1.5 35B, Nemotron 3.5 Lightning, Muse Glimmer 30B, and Qwen3.8-27B. This is a useful signal precisely because it's not about frontier models, it's about which locally-runnable model can actually hold an autonomous loop together, which is what matters if you want to run this without an API bill.
https://x.com/tonbistudio/status/2094435654125883417
A hardware-grounded benchmark: which local model that fits on a DGX Spark performs autoresearch the best. The contenders are Ornith 1.5 35B, Nemotron 3.5 Lightning, Muse Glimmer 30B, and Qwen3.8-27B. This is a useful signal precisely because it's not about frontier models, it's about which locally-runnable model can actually hold an autonomous loop together, which is what matters if you want to run this without an API bill.
#8
@Joelc_eth
https://x.com/Joelc_eth/status/2094231180665131149
A pointed from-experience take: for autoresearch, Fable and GLM 5.3 are hands down the two best models right now. Both excel across the same end-to-end loop, proposing solid hypotheses, writing clean code, running experiments, evaluating metrics autonomously. His key claim is durability: leave them running for hours on their own and they keep making steady progress without derailing or losing context, which he says nothing else currently pulls off. The interesting shift here is that the model benchmark that matters is no longer a single answer, it's how long it can hold a loop.
https://x.com/Joelc_eth/status/2094231180665131149
A pointed from-experience take: for autoresearch, Fable and GLM 5.3 are hands down the two best models right now. Both excel across the same end-to-end loop, proposing solid hypotheses, writing clean code, running experiments, evaluating metrics autonomously. His key claim is durability: leave them running for hours on their own and they keep making steady progress without derailing or losing context, which he says nothing else currently pulls off. The interesting shift here is that the model benchmark that matters is no longer a single answer, it's how long it can hold a loop.
#9
@juanbenet
https://x.com/juanbenet/status/2093803783495016567
A high-altitude read from a notable builder. He frames Karpathy-style autoresearch loops as one of several "unhobblings" that squeeze utility out of current capabilities, alongside code and cowork agents and Lean-plus-"do-a-breakthrough" setups. His judgment is that current capabilities are already sufficient to greatly accelerate scientific discovery, and that the slope of the singularity can really be felt now, with new materials, molecules, and proteins all ripe for discovery through these loops.
https://x.com/juanbenet/status/2093803783495016567
A high-altitude read from a notable builder. He frames Karpathy-style autoresearch loops as one of several "unhobblings" that squeeze utility out of current capabilities, alongside code and cowork agents and Lean-plus-"do-a-breakthrough" setups. His judgment is that current capabilities are already sufficient to greatly accelerate scientific discovery, and that the slope of the singularity can really be felt now, with new materials, molecules, and proteins all ripe for discovery through these loops.
#10
@NatKokoromyti
https://x.com/NatKokoromyti/status/2094525364668383318
A speculative but vivid extension of the loop into the physical world. Reacting to RL for mechanical design, he imagines a future where you give a robot a task and a 3D printer, and it prints the parts it needs, hands, tools, and runs autoresearch for physical AI. It's the same optimize-against-a-metric loop, except the sandbox is the real world and the artifacts are physical.
https://x.com/NatKokoromyti/status/2094525364668383318
A speculative but vivid extension of the loop into the physical world. Reacting to RL for mechanical design, he imagines a future where you give a robot a task and a 3D printer, and it prints the parts it needs, hands, tools, and runs autoresearch for physical AI. It's the same optimize-against-a-metric loop, except the sandbox is the real world and the artifacts are physical.
#11
@encrypt_wizard
https://x.com/encrypt_wizard/status/2093983327111811233
The cleanest articulation of the week's most-discussed idea, from a GenLayer livestream. The concept: autoresearch opened up to strangers. Set up a repo with a goal you can actually measure, then let anyone point a spare agent at it. That works right up until the contributors aren't your friends and someone starts gaming the system. The proposed fix is an intelligent contract that sits in the judge's seat, reads every PR, and decides whether it's a real improvement or incentive farming before issuing credit. It's a serious answer to the core problem of open autoresearch: how do you trust contributions you didn't supervise.
https://x.com/encrypt_wizard/status/2093983327111811233
The cleanest articulation of the week's most-discussed idea, from a GenLayer livestream. The concept: autoresearch opened up to strangers. Set up a repo with a goal you can actually measure, then let anyone point a spare agent at it. That works right up until the contributors aren't your friends and someone starts gaming the system. The proposed fix is an intelligent contract that sits in the judge's seat, reads every PR, and decides whether it's a real improvement or incentive farming before issuing credit. It's a serious answer to the core problem of open autoresearch: how do you trust contributions you didn't supervise.
#12
@DojiStar11
https://x.com/DojiStar11/status/2093737348790153632
A small, concrete build straight out of an agent loop. He had his loop build an app that exports a trader's X posts and turns their buy and sell posts into a web app, so he can see how those trades actually played out. It's the everyday version of what these loops are for: describe an outcome, let the loop assemble the tool.
https://x.com/DojiStar11/status/2093737348790153632
A small, concrete build straight out of an agent loop. He had his loop build an app that exports a trader's X posts and turns their buy and sell posts into a web app, so he can see how those trades actually played out. It's the everyday version of what these loops are for: describe an outcome, let the loop assemble the tool.
#13
@fialaerik
https://x.com/fialaerik/status/2093830303240565162
An honest agent-loop diary that captures the current failure mode perfectly. He had Claude Code clean up session state; it said done, tests passing. The tests were not passing. So half his AGENTS.md is now just "run the tests and paste the output," and he still reads every diff himself. His summary, trust the agent, verify the diff, is the whole discipline of running these loops in one line.
https://x.com/fialaerik/status/2093830303240565162
An honest agent-loop diary that captures the current failure mode perfectly. He had Claude Code clean up session state; it said done, tests passing. The tests were not passing. So half his AGENTS.md is now just "run the tests and paste the output," and he still reads every diff himself. His summary, trust the agent, verify the diff, is the whole discipline of running these loops in one line.
#14
@ArtAndAlgo
https://x.com/ArtAndAlgo/status/2094070902963003736
A homemade self-improving loop that grew emergent. He taught his system on Google's Titan paper, the core idea being learn from surprise: if something surprises you it's interesting, and if it's interesting, remember it. Now bugs, failures, improvements, and offhand things he says all get treated as interesting, filed as git issues, and an agent watches git and drains the queue. The system feeds itself, and he's now trying to figure out how to close all the loops. It's an individual reproducing the compounding-memory pattern the labs are formalizing.
https://x.com/ArtAndAlgo/status/2094070902963003736
A homemade self-improving loop that grew emergent. He taught his system on Google's Titan paper, the core idea being learn from surprise: if something surprises you it's interesting, and if it's interesting, remember it. Now bugs, failures, improvements, and offhand things he says all get treated as interesting, filed as git issues, and an agent watches git and drains the queue. The system feeds itself, and he's now trying to figure out how to close all the loops. It's an individual reproducing the compounding-memory pattern the labs are formalizing.
#15
@miketromba
https://x.com/miketromba/status/2094078987320320006
A practical design tip for making a product itself self-improving. Add a submit_feedback tool to your MCP and encourage agents to post into it any time the user is confused, the agent is blocked, friction shows up, or something isn't yet possible. Then continually process that inbox with LLMs to aggregate product insights, and for bonus points, close the loop by having an agent monitor the insights and open tickets or PRs on autopilot.
https://x.com/miketromba/status/2094078987320320006
A practical design tip for making a product itself self-improving. Add a submit_feedback tool to your MCP and encourage agents to post into it any time the user is confused, the agent is blocked, friction shows up, or something isn't yet possible. Then continually process that inbox with LLMs to aggregate product insights, and for bonus points, close the loop by having an agent monitor the insights and open tickets or PRs on autopilot.
#16
@0xkasana
https://x.com/0xkasana/status/2094014786451173583
Traceroot is an open-source observability and self-improving layer for AI agents. You instrument your agent, a detector scans production traces for the things a dashboard misses, hallucinations, wrong tool calls, dropped user intent, then it runs root cause against your own source and GitHub history and opens a fix PR, with every fix evaluated before it counts as done. It's the autoresearch loop applied to the agent's own reliability rather than to an external metric.
https://x.com/0xkasana/status/2094014786451173583
Traceroot is an open-source observability and self-improving layer for AI agents. You instrument your agent, a detector scans production traces for the things a dashboard misses, hallucinations, wrong tool calls, dropped user intent, then it runs root cause against your own source and GitHub history and opens a fix PR, with every fix evaluated before it counts as done. It's the autoresearch loop applied to the agent's own reliability rather than to an external metric.
π‘ Eco Products Radar
Eco Products Radar
Products, tools, and frameworks mentioned three or more times across today's posts:
pi-autoresearch, the optimization loop people keep pointing at everything from context policy to CUDA kernels.
OpenResearch CLI and Campfire, the local, multi-agent autoresearch stack and its coordination layer.
GenLayer, repeatedly floated as the trust-and-judge layer for opening autoresearch to strangers.
Claude Code, Codex, and OpenCode, the agent CLIs people run in parallel worktrees inside these loops.
omp (Pi) with its /autoresearch mode, driving the long overnight kernel and shader runs.
Fable and GLM 5.3, the models singled out for holding a loop for hours without derailing.
Products, tools, and frameworks mentioned three or more times across today's posts:
pi-autoresearch, the optimization loop people keep pointing at everything from context policy to CUDA kernels.
OpenResearch CLI and Campfire, the local, multi-agent autoresearch stack and its coordination layer.
GenLayer, repeatedly floated as the trust-and-judge layer for opening autoresearch to strangers.
Claude Code, Codex, and OpenCode, the agent CLIs people run in parallel worktrees inside these loops.
omp (Pi) with its /autoresearch mode, driving the long overnight kernel and shader runs.
Fable and GLM 5.3, the models singled out for holding a loop for hours without derailing.
Comments