Loop Daily: August 17, 2026
Autoresearch stopped being a vibe and became a published artifact yesterday. A study went out with the full traces, scratchpads and reasoning streams from open-weight models attached, plus the experiment setup, and the reaction from people building in this space was less about the headline result than about the data itself. Underneath that, the practical thread was consistent and slightly boring in the best way: a loop without a metric is just expensive noise, the keep-or-revert decision is the whole product, and the thing that actually decides whether a loop compounds or drifts is the harness around the model rather than the model. The failure reports were the most useful part. A self-improving loop inherits your preprocessing bugs at speed. An unsafe one-off success becomes a permanently stored skill. And a loop with no independent checkpoint just rewards drift faster.
#1
@oscarmoxon
https://x.com/oscarmoxon/status/2088738661244514473
He calls it the first auto-research study of its kind, and the framing is deliberately three-part: what frontier systems can do today, how they fail, and what sits on the horizon for recursive self-improvement. That middle part is the one the field keeps skipping. Most published autoresearch demos show the successful trajectory and quietly drop the runs where the loop wandered off, so a study that treats failure modes as a first-class result is more useful than another highlight reel.
https://x.com/oscarmoxon/status/2088738661244514473
He calls it the first auto-research study of its kind, and the framing is deliberately three-part: what frontier systems can do today, how they fail, and what sits on the horizon for recursive self-improvement. That middle part is the one the field keeps skipping. Most published autoresearch demos show the successful trajectory and quietly drop the runs where the loop wandered off, so a study that treats failure modes as a first-class result is more useful than another highlight reel.
#2
@tokenbender
https://x.com/tokenbender/status/2088738655833907468
His reaction to the same release goes straight to the asset nobody usually ships: full traces, scratchpads, reasoning streams from open-weight models, and the experiment setup. His line is that hundreds of startups working on autoresearch across the globe are drooling after exactly this data. That is the real bottleneck in this space right now. Anyone can describe a loop; almost nobody publishes what the loop actually thought on the runs that went nowhere, and that is precisely the material you need to train or evaluate the next one.
https://x.com/tokenbender/status/2088738655833907468
His reaction to the same release goes straight to the asset nobody usually ships: full traces, scratchpads, reasoning streams from open-weight models, and the experiment setup. His line is that hundreds of startups working on autoresearch across the globe are drooling after exactly this data. That is the real bottleneck in this space right now. Anyone can describe a loop; almost nobody publishes what the loop actually thought on the runs that went nowhere, and that is precisely the material you need to train or evaluate the next one.
#3
@eliebakouch
https://x.com/eliebakouch/status/2088745056564109682
His credit list is effectively a map of who is doing serious work on the loop: METR's evaluations, Recursive_SI, Keller Jordan's modded-nanogpt and everyone who contributed to that speedrun, and Karpathy's nanogpt and autoresearch work as the thing that pulled a lot of people into this area in the first place. The modded-nanogpt lineage matters more than it looks. A public speedrun with a fixed target and a shared scoreboard is the cleanest possible autoresearch benchmark, because the metric is unambiguous and the improvements are all verifiable by replay.
https://x.com/eliebakouch/status/2088745056564109682
His credit list is effectively a map of who is doing serious work on the loop: METR's evaluations, Recursive_SI, Keller Jordan's modded-nanogpt and everyone who contributed to that speedrun, and Karpathy's nanogpt and autoresearch work as the thing that pulled a lot of people into this area in the first place. The modded-nanogpt lineage matters more than it looks. A public speedrun with a fixed target and a shared scoreboard is the cleanest possible autoresearch benchmark, because the metric is unambiguous and the improvements are all verifiable by replay.
#4
@iScienceLuvr
https://x.com/iScienceLuvr/status/2088759372457652578
He calls the Prime Intellect run a great experiment and then does the thing more people should: names what he actually uses. He has been running his own autoresearch experiments mainly on GPT-5.6 Sol and is now wondering whether to switch to Claude or at least Kimi K3. His open question about the study is the sharp one: prime-agent improved Kimi-K3, but they did not test whether it also improves Sol and Fable, so it is unclear whether the gain belongs to the harness or to the specific model it was tuned against.
https://x.com/iScienceLuvr/status/2088759372457652578
He calls the Prime Intellect run a great experiment and then does the thing more people should: names what he actually uses. He has been running his own autoresearch experiments mainly on GPT-5.6 Sol and is now wondering whether to switch to Claude or at least Kimi K3. His open question about the study is the sharp one: prime-agent improved Kimi-K3, but they did not test whether it also improves Sol and Fable, so it is unclear whether the gain belongs to the harness or to the specific model it was tuned against.
#5
@suoyu007
https://x.com/suoyu007/status/2088628735767409077
The clearest description of what Prime Intellect actually open-sourced. prime-agent is a self-improving RLM harness where the agent lives in a persistent REPL, calls tools by writing Python rather than by filling in a tool schema, spawns subagents as ordinary function calls, and patches its own playbook using evidence from previous runs. His closing note is the important one: it is built for long jobs, not chat demos. Every design choice there is downstream of that, especially the persistent REPL, which is what lets state survive between iterations instead of being reconstructed from a transcript.
https://x.com/suoyu007/status/2088628735767409077
The clearest description of what Prime Intellect actually open-sourced. prime-agent is a self-improving RLM harness where the agent lives in a persistent REPL, calls tools by writing Python rather than by filling in a tool schema, spawns subagents as ordinary function calls, and patches its own playbook using evidence from previous runs. His closing note is the important one: it is built for long jobs, not chat demos. Every design choice there is downstream of that, especially the persistent REPL, which is what lets state survive between iterations instead of being reconstructed from a transcript.
#6
@DanKornas
https://x.com/DanKornas/status/2088726164244173152
He shipped Autoresearch as an autonomous iteration skill for Claude Code, OpenCode and Codex, and the mechanism is refreshingly narrow: establish a baseline, make one focused change, verify the result, keep it or revert it. Verification is mechanical, tests or benchmarks or scores or any other measurable result, and rollback is automatic when the metric gets worse. Iteration is bounded by default with unlimited runs as an explicit opt-in, there are fourteen commands covering plan, debug, fix, security audit, scenario exploration, regression checks and shipping, and the Claude Code install adds hook-level guardrails. MIT licensed.
https://x.com/DanKornas/status/2088726164244173152
He shipped Autoresearch as an autonomous iteration skill for Claude Code, OpenCode and Codex, and the mechanism is refreshingly narrow: establish a baseline, make one focused change, verify the result, keep it or revert it. Verification is mechanical, tests or benchmarks or scores or any other measurable result, and rollback is automatic when the metric gets worse. Iteration is bounded by default with unlimited runs as an explicit opt-in, there are fourteen commands covering plan, debug, fix, security audit, scenario exploration, regression checks and shipping, and the Claude Code install adds hook-level guardrails. MIT licensed.
#7
@aftaab___
https://x.com/aftaab___/status/2088730843502248273
One sentence that summarises the whole category better than most threads: agents without a metric and a keep/revert loop just generate expensive noise. His follow-on is that autoresearch looks like the missing piece for turning Claude Code or Codex into something that actually compounds. That word compounds is doing the work. A coding agent without a scoreboard produces a pile of plausible diffs; the same agent with a baseline and a revert rule produces a monotonically improving artifact, and the difference in cost per unit of real progress is enormous.
https://x.com/aftaab___/status/2088730843502248273
One sentence that summarises the whole category better than most threads: agents without a metric and a keep/revert loop just generate expensive noise. His follow-on is that autoresearch looks like the missing piece for turning Claude Code or Codex into something that actually compounds. That word compounds is doing the work. A coding agent without a scoreboard produces a pile of plausible diffs; the same agent with a baseline and a revert rule produces a monotonically improving artifact, and the difference in cost per unit of real progress is enormous.
#8
@tonytonggg
https://x.com/tonytonggg/status/2088661811105300682
The most useful failure report of the day. Self-improving loops inherit your preprocessing bugs at speed. The weirdest bug he fixed was a classifier that disagreed with itself, because the same face cropped differently embedded differently. Standardising the crops fixed it. His conclusion is a good corrective to the current discourse: graphs are the fun slide, data consistency is the engineering. If your metric is measuring a preprocessing artifact, an autonomous loop will optimise straight into that artifact, faster and more thoroughly than a human ever would.
https://x.com/tonytonggg/status/2088661811105300682
The most useful failure report of the day. Self-improving loops inherit your preprocessing bugs at speed. The weirdest bug he fixed was a classifier that disagreed with itself, because the same face cropped differently embedded differently. Standardising the crops fixed it. His conclusion is a good corrective to the current discourse: graphs are the fun slide, data consistency is the engineering. If your metric is measuring a preprocessing artifact, an autonomous loop will optimise straight into that artifact, faster and more thoroughly than a human ever would.
#9
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2088706577205432740
Actual numbers on agentic loop efficiency, from an experiment run by thehypedotnews across the same three builds: Grok 4.6 spent $13.11 against GPT-5.6 Sol's $20.18. The edge came from taking bigger coding steps, 201 model calls versus 338. But the number he pulls out as the real story is 93 to 98 percent of input tokens being cache reads. The runs consumed roughly 20M tokens for Grok and 26M for Sol, and the author estimates they would have cost around four times more without prompt caching. Loop economics are now mostly cache economics.
https://x.com/rohanpaul_ai/status/2088706577205432740
Actual numbers on agentic loop efficiency, from an experiment run by thehypedotnews across the same three builds: Grok 4.6 spent $13.11 against GPT-5.6 Sol's $20.18. The edge came from taking bigger coding steps, 201 model calls versus 338. But the number he pulls out as the real story is 93 to 98 percent of input tokens being cache reads. The runs consumed roughly 20M tokens for Grok and 26M for Sol, and the author estimates they would have cost around four times more without prompt caching. Loop economics are now mostly cache economics.
#10
@jerryjliu0
https://x.com/jerryjliu0/status/2088752023420248352
His argument is that model routing belongs at the harness layer, not the gateway layer, and it lands because it is specific. Every task is solved by a combination of a model mixture and an agent harness, and every task needs a different mixture to sit on the accuracy-cost pareto frontier. Optimise at the gateway and you lose all the context encoded in the harness, so you are only optimising at the completion layer. Optimise at the harness and you can make the model choices both a priori and while inside the agent loop. His stronger claim is that the model mixture and the harness shape are co-optimised, so one only really exists with the other.
https://x.com/jerryjliu0/status/2088752023420248352
His argument is that model routing belongs at the harness layer, not the gateway layer, and it lands because it is specific. Every task is solved by a combination of a model mixture and an agent harness, and every task needs a different mixture to sit on the accuracy-cost pareto frontier. Optimise at the gateway and you lose all the context encoded in the harness, so you are only optimising at the completion layer. Optimise at the harness and you can make the model choices both a priori and while inside the agent loop. His stronger claim is that the model mixture and the harness shape are co-optimised, so one only really exists with the other.
#11
@arvidkahl
https://x.com/arvidkahl/status/2088703233212747843
The definitive statement on why loops need external verification: tests are the only way to reliably enforce that changes do not have side effects outside the scope of the agentic loop. Most agents only look at the files they have to edit and never at everything else that interacts with them. He wants unit, feature, integration and end-to-end tests, plus fuzzing or mutation testing for edge cases, and on the harness side explicit expectations for what tests should look like, what they cover, how they mock dependencies, and whether the agent is even allowed to remove or change existing tests. His fix for the obvious next problem, that generated tests are themselves error-prone, is adversarial review by a second model.
https://x.com/arvidkahl/status/2088703233212747843
The definitive statement on why loops need external verification: tests are the only way to reliably enforce that changes do not have side effects outside the scope of the agentic loop. Most agents only look at the files they have to edit and never at everything else that interacts with them. He wants unit, feature, integration and end-to-end tests, plus fuzzing or mutation testing for edge cases, and on the harness side explicit expectations for what tests should look like, what they cover, how they mock dependencies, and whether the agent is even allowed to remove or change existing tests. His fix for the obvious next problem, that generated tests are themselves error-prone, is adversarial review by a second model.
#12
@pauliusztin_
https://x.com/pauliusztin_/status/2088604119065911735
He is rebuilding a Claude Code replica from scratch and his headline finding is the one everyone underestimates: a bare-bones coding agent loop is surprisingly small, and the hard part is everything required to make it usable. His first attempt tried to build the TUI, loop, tools, skills, memory and compaction at once and became impossible to reason about, so he restarted after studying Claude Code, OpenCode, Aider and Pi. Two details stand out. New human instructions cannot be injected anywhere safely, so his harness buffers steering, follow-ups and aborts and injects them at safe boundaries between tool calls. And every completed turn is persisted to an append-only JSONL log, which is what makes sessions resumable and failures debuggable.
https://x.com/pauliusztin_/status/2088604119065911735
He is rebuilding a Claude Code replica from scratch and his headline finding is the one everyone underestimates: a bare-bones coding agent loop is surprisingly small, and the hard part is everything required to make it usable. His first attempt tried to build the TUI, loop, tools, skills, memory and compaction at once and became impossible to reason about, so he restarted after studying Claude Code, OpenCode, Aider and Pi. Two details stand out. New human instructions cannot be injected anywhere safely, so his harness buffers steering, follow-ups and aborts and injects them at safe boundaries between tool calls. And every completed turn is persisted to an append-only JSONL log, which is what makes sessions resumable and failures debuggable.
#13
@MaziyarPanahi
https://x.com/MaziyarPanahi/status/2088698685123170570
A small, real, two-model loop. He wrote a minimal agent loop to have Qwen build a game, which he found raw and flexible, then had Codex call Qwen to produce a list of assets and the instructions for generating each image, and let Codex run that part as a loop because it already has an image generation skill. The pattern is worth stealing: use the cheap flexible loop for the open-ended construction, and hand the repetitive generation stage to whichever harness already has a native tool for it.
https://x.com/MaziyarPanahi/status/2088698685123170570
A small, real, two-model loop. He wrote a minimal agent loop to have Qwen build a game, which he found raw and flexible, then had Codex call Qwen to produce a list of assets and the instructions for generating each image, and let Codex run that part as a loop because it already has an image generation skill. The pattern is worth stealing: use the cheap flexible loop for the open-ended construction, and hand the repetitive generation stage to whichever harness already has a native tool for it.
#14
@0xNeoNat
https://x.com/0xNeoNat/status/2088694726719594595
The needed deflation. Looking at a vault-editing agent setup, he points out it is really git branching applied to a vault: write to a branch, a critic reviews the diff, merge if clean. Nothing wrong with that, but it is useful to recognise it as proven version control discipline wearing an agent loop label. Most of the loop designs working today are exactly this, and saying so plainly makes it easier to reason about what is actually novel and what is a rename.
https://x.com/0xNeoNat/status/2088694726719594595
The needed deflation. Looking at a vault-editing agent setup, he points out it is really git branching applied to a vault: write to a branch, a critic reviews the diff, merge if clean. Nothing wrong with that, but it is useful to recognise it as proven version control discipline wearing an agent loop label. Most of the loop designs working today are exactly this, and saying so plainly makes it easier to reason about what is actually novel and what is a rename.
#15
@Secondmindsys
https://x.com/Secondmindsys/status/2088673951610204513
The dangerous part of agent memory is not forgetting, it is remembering the wrong thing for too long. A past instruction can be useful when written, stale three weeks later, and actively harmful once the environment changes, and the same holds for decisions, preferences, retrieved facts, learned skills and successful workflows. So persistent memory creates a harder problem than storage: what from the past still deserves influence over the next decision? That question is exactly where a long-running self-improving loop breaks, because a loop with unpruned memory will keep re-deriving conclusions from conditions that no longer hold.
https://x.com/Secondmindsys/status/2088673951610204513
The dangerous part of agent memory is not forgetting, it is remembering the wrong thing for too long. A past instruction can be useful when written, stale three weeks later, and actively harmful once the environment changes, and the same holds for decisions, preferences, retrieved facts, learned skills and successful workflows. So persistent memory creates a harder problem than storage: what from the past still deserves influence over the next decision? That question is exactly where a long-running self-improving loop breaks, because a loop with unpruned memory will keep re-deriving conclusions from conditions that no longer hold.
#16
@TechThought_org
https://x.com/TechThought_org/status/2088461261356794094
New research introduces SkillMisevo-Gym to track how self-improving agents retain potentially unsafe routines over time. The mechanism it names is the one that should worry people running unattended loops: when a transient success becomes a permanent policy, alignment risk compounds rather than staying local. This is the natural failure mode of any system that promotes successful trajectories into a reusable skill library, because "it worked once" is a much weaker signal than the storage mechanism implies.
https://x.com/TechThought_org/status/2088461261356794094
New research introduces SkillMisevo-Gym to track how self-improving agents retain potentially unsafe routines over time. The mechanism it names is the one that should worry people running unattended loops: when a transient success becomes a permanent policy, alignment risk compounds rather than staying local. This is the natural failure mode of any system that promotes successful trajectories into a reusable skill library, because "it worked once" is a much weaker signal than the storage mechanism implies.
#17
@nykdotdev
https://x.com/nykdotdev/status/2088458274030911545
One line, but it names the exact failure: self-improving agents need checkpointed output evals, or the loop rewards drift. Without a fixed evaluation held outside the loop, the system optimises against whatever the loop happens to be measuring at that moment, which slides over iterations. The keep-or-revert baseline in the autoresearch designs above is the concrete answer to this.
https://x.com/nykdotdev/status/2088458274030911545
One line, but it names the exact failure: self-improving agents need checkpointed output evals, or the loop rewards drift. Without a fixed evaluation held outside the loop, the system optimises against whatever the loop happens to be measuring at that moment, which slides over iterations. The keep-or-revert baseline in the autoresearch designs above is the concrete answer to this.
#18
@cyrilXBT
https://x.com/cyrilXBT/status/2088542962854629672
He swapped Opus 5 for DeepSeek V4-Flash and says it is basically free, and points at a setup where someone got its subagents running as a self-improving loop inside Codex. The recipe he gives is three steps: clone the codex-self-improving-loop repo, hand the agent a "3 loop workflow" image as the spec, done. The image-as-spec trick is the interesting part, and it is a live example of the wider shift: as the model layer commoditises, what gets shared and copied is the loop shape, not the weights.
https://x.com/cyrilXBT/status/2088542962854629672
He swapped Opus 5 for DeepSeek V4-Flash and says it is basically free, and points at a setup where someone got its subagents running as a self-improving loop inside Codex. The recipe he gives is three steps: clone the codex-self-improving-loop repo, hand the agent a "3 loop workflow" image as the spec, done. The image-as-spec trick is the interesting part, and it is a live example of the wider shift: as the model layer commoditises, what gets shared and copied is the loop shape, not the weights.
#19
@0xClandestine
https://x.com/0xClandestine/status/2088760775489798537
He says he has personally spent days of his life optimising previous versions of 27b, and that it was costly, time consuming and slow going. His bet is that collaborative auto-research changes that narrative, and he is calling for people to work on it together. That is a specific claim worth watching: not that a loop beats a human on any single optimisation, but that many people running loops against a shared target compounds in a way that individual grinding never did.
https://x.com/0xClandestine/status/2088760775489798537
He says he has personally spent days of his life optimising previous versions of 27b, and that it was costly, time consuming and slow going. His bet is that collaborative auto-research changes that narrative, and he is calling for people to work on it together. That is a specific claim worth watching: not that a loop beats a human on any single optimisation, but that many people running loops against a shared target compounds in a way that individual grinding never did.
#20
@stretchcloud
https://x.com/stretchcloud/status/2088485836593811629
His read on DeepSeek's harness release is the one relevant to this section: it is not just that tools are plugins, it is that the model adapter, the session log and the agent loop itself are plugins, swappable at config time with no source changes. The paper behind it formalises this as spatiotemporal composability, every component in the agent execution graph replaceable across time and environment. If the loop is a config-level component, then loop design becomes something you can A/B test rather than something you rewrite a harness to try, which is the precondition for doing autoresearch on the harness itself.
https://x.com/stretchcloud/status/2088485836593811629
His read on DeepSeek's harness release is the one relevant to this section: it is not just that tools are plugins, it is that the model adapter, the session log and the agent loop itself are plugins, swappable at config time with no source changes. The paper behind it formalises this as spatiotemporal composability, every component in the agent execution graph replaceable across time and environment. If the loop is a config-level component, then loop design becomes something you can A/B test rather than something you rewrite a harness to try, which is the precondition for doing autoresearch on the harness itself.
#21
@teortaxesTex
https://x.com/teortaxesTex/status/2088774991986770283
The landscape claim, with names attached. Every serious lab has recursive self-improvement running: OpenAI with an internal system he describes as an AGI intern that they scale up in weeks, Kimi, GLM, and DeepSeek, which he estimates is blasting trillions of tokens a day on autoresearch behind an Opus-4.8-class model. Whether or not the specific numbers hold, the structural point is the one to sit with: autoresearch has moved from being a public research topic to being internal capacity that nobody has to publish.
https://x.com/teortaxesTex/status/2088774991986770283
The landscape claim, with names attached. Every serious lab has recursive self-improvement running: OpenAI with an internal system he describes as an AGI intern that they scale up in weeks, Kimi, GLM, and DeepSeek, which he estimates is blasting trillions of tokens a day on autoresearch behind an Opus-4.8-class model. Whether or not the specific numbers hold, the structural point is the one to sit with: autoresearch has moved from being a public research topic to being internal capacity that nobody has to publish.
#22
@lastktn
https://x.com/lastktn/status/2088529122448285887
On Andrew Ng's claim that agents handle nearly all his tasks and that self-improving orchestration becomes standard infrastructure in three to six months, the reframe is the useful bit: self-improving does not mean the agent got smarter, it means the loop got tighter. What that looks like in production right now is agents logging their own failure states in real time, child agents spinning up to retry with adjusted parameters, eval nodes checking output quality before any action commits, and memory layers feeding corrected runs back into active context. The gap is harness design, not model access.
https://x.com/lastktn/status/2088529122448285887
On Andrew Ng's claim that agents handle nearly all his tasks and that self-improving orchestration becomes standard infrastructure in three to six months, the reframe is the useful bit: self-improving does not mean the agent got smarter, it means the loop got tighter. What that looks like in production right now is agents logging their own failure states in real time, child agents spinning up to retry with adjusted parameters, eval nodes checking output quality before any action commits, and memory layers feeding corrected runs back into active context. The gap is harness design, not model access.
#23
@mrgadgetstudio
https://x.com/mrgadgetstudio/status/2088748567905096104
A clean three-level ladder for AI coding: write code on request, autonomously maintain the product, improve its own workflow. His claim is that Anthropic has already touched level three, in that Claude's routines are tuned from failures so they perform better the next day. He is careful to note this is not self-training, it is an early feedback loop pointed toward self-improving agents. That distinction is worth keeping, because most of what gets called self-improvement right now is a scaffolding update, not a weight update.
https://x.com/mrgadgetstudio/status/2088748567905096104
A clean three-level ladder for AI coding: write code on request, autonomously maintain the product, improve its own workflow. His claim is that Anthropic has already touched level three, in that Claude's routines are tuned from failures so they perform better the next day. He is careful to note this is not self-training, it is an early feedback loop pointed toward self-improving agents. That distinction is worth keeping, because most of what gets called self-improvement right now is a scaffolding update, not a weight update.
#24
@betterhn50
https://x.com/betterhn50/status/2088637336007393532
Sitting near the top of Hacker News yesterday: auto-research with Codex, a 232x faster kernel. Kernel optimisation is the ideal shape for this loop, an editable file plus a benchmark that returns a single number in seconds, which is exactly the condition under which keep-or-revert works without human judgment. The size of the multiple is what makes it circulate, but the reason it is repeatable is the measurability, not the model.
https://x.com/betterhn50/status/2088637336007393532
Sitting near the top of Hacker News yesterday: auto-research with Codex, a 232x faster kernel. Kernel optimisation is the ideal shape for this loop, an editable file plus a benchmark that returns a single number in seconds, which is exactly the condition under which keep-or-revert works without human judgment. The size of the multiple is what makes it circulate, but the reason it is repeatable is the measurability, not the model.
π‘ Eco Products Radar
Eco Products Radar
prime-agent (Prime Intellect) β the self-improving RLM harness of the week, persistent REPL, subagents as functions, self-patching playbook
Claude Code β the most common host for autoresearch skills and loop scaffolding
Codex β the other default loop host, and the one running the 232x kernel case
Autoresearch skill (DanKornas) β baseline, one change, verify, keep or revert, with automatic rollback
DeepSeek Harness β where the agent loop itself became a swappable plugin
Kimi K3 β the model prime-agent was measured against
GPT-5.6 Sol and Grok 4.6 β the two models being compared on loop cost and step size
modded-nanogpt β the speedrun lineage that gives autoresearch a clean shared benchmark
prime-agent (Prime Intellect) β the self-improving RLM harness of the week, persistent REPL, subagents as functions, self-patching playbook
Claude Code β the most common host for autoresearch skills and loop scaffolding
Codex β the other default loop host, and the one running the 232x kernel case
Autoresearch skill (DanKornas) β baseline, one change, verify, keep or revert, with automatic rollback
DeepSeek Harness β where the agent loop itself became a swappable plugin
Kimi K3 β the model prime-agent was measured against
GPT-5.6 Sol and Grok 4.6 β the two models being compared on loop cost and step size
modded-nanogpt β the speedrun lineage that gives autoresearch a clean shared benchmark
Comments