Loop Daily: 2026-11-14
Autoresearch stopped being a weekend toy this week and started showing up as a line item inside real research orgs. Edison's six-person team says Kosmos now does most of its own research, and Andrew White walked through one full cycle: build a benchmark for context compaction, adopt the best open-source method, then let the loop hill-climb a utility that prices in cost and latency until it hit the top of that benchmark. The sharper posts this week were about the judge, not the agent. A benchmark finds that almost every model explores fewer than two idea basins, an eval bug let a diverged run with tied scores post a near-top AUC, and Vapi's new self-improving voice loop ships with a locked list of decisions the agent isn't allowed to unlearn. The timeline was again flooded with copy-paste threads about Karpathy's repos and a paper counting 217 real loops in 36,487 repos. Under the noise the takeaway is simple: whoever owns the scorer owns the loop.
#1
@andrewwhite01
https://x.com/andrewwhite01/status/2121283868670242832
andrewwhite01 describes how the Kosmos team approached context compaction. They built KosmosCompactBench to compare compaction algorithms from the frontier labs and about five open-source harnesses, found Prime Intellect's method was the best open one, and adopted it as the baseline. Then they pointed autoresearch at it with a utility function that mixes benchmark score, cost and latency, and later posts in the thread say the loop reached state of the art on their benchmark. The order is the lesson: the benchmark came first and the loop came second, so there was something honest to climb.
https://x.com/andrewwhite01/status/2121283868670242832
andrewwhite01 describes how the Kosmos team approached context compaction. They built KosmosCompactBench to compare compaction algorithms from the frontier labs and about five open-source harnesses, found Prime Intellect's method was the best open one, and adopted it as the baseline. Then they pointed autoresearch at it with a utility function that mixes benchmark score, cost and latency, and later posts in the thread say the loop reached state of the art on their benchmark. The order is the lesson: the benchmark came first and the loop came second, so there was something honest to climb.
#2
@SGRodriques
https://x.com/SGRodriques/status/2121292082287677590
SGRodriques points to a write-up by Edison's Sid Narayanan on what self-improvement looks like inside a working research org, using the compaction project as the case study. Edison's research team is only six or seven people but owns Kosmos' performance across the whole biotech R&D pipeline. The claim is that productivity rose sharply over six months because Kosmos now does most of the research itself. A tiny team owning a whole pipeline is the profile where autoresearch pays off: lots of measurable surface and too few people to touch it by hand.
https://x.com/SGRodriques/status/2121292082287677590
SGRodriques points to a write-up by Edison's Sid Narayanan on what self-improvement looks like inside a working research org, using the compaction project as the case study. Edison's research team is only six or seven people but owns Kosmos' performance across the whole biotech R&D pipeline. The claim is that productivity rose sharply over six months because Kosmos now does most of the research itself. A tiny team owning a whole pipeline is the profile where autoresearch pays off: lots of measurable surface and too few people to touch it by hand.
#3
@RohanArun
https://x.com/RohanArun/status/2120904514890833924
RohanArun gives an update on an open Yang-Mills mass gap auto-research repo and walks back the hype first: it's a path for agents, not a discovery. The group verified the upstream Lean chain, built a conditional one-step SU(2) model, corrected a novelty claim, and published two negative scope results so later agents don't repeat dead ends. The same method already pushed bounds on the QRH and integer multiplication papers, where some top contributors were 14 to 16 years old. Rohan also names the concern professors raised, which is that confident agent mistakes are flooding review queues, and the group's answer is to require Lean formalization rather than accept text.
https://x.com/RohanArun/status/2120904514890833924
RohanArun gives an update on an open Yang-Mills mass gap auto-research repo and walks back the hype first: it's a path for agents, not a discovery. The group verified the upstream Lean chain, built a conditional one-step SU(2) model, corrected a novelty claim, and published two negative scope results so later agents don't repeat dead ends. The same method already pushed bounds on the QRH and integer multiplication papers, where some top contributors were 14 to 16 years old. Rohan also names the concern professors raised, which is that confident agent mistakes are flooding review queues, and the group's answer is to require Lean formalization rather than accept text.
#4
@mardehaym
https://x.com/mardehaym/status/2120965208487453137
mardehaym says the coding loop itself (plan, edit, run tests, fix, open a PR) takes a weekend, and the six things around it take months. One gateway for every model call with a spend cap per key, a fresh sandbox with no credentials for each task, hard caps on attempts and cost so stuck tasks go back to the board, traceability from line to session to commit to ticket to epic, prompt changes gated on test cases, and a human approving every merge. When a CTO asks whether to build in-house, the reply is to count how many of the six already exist. It's the most usable build-versus-buy checklist on the timeline this week.
https://x.com/mardehaym/status/2120965208487453137
mardehaym says the coding loop itself (plan, edit, run tests, fix, open a PR) takes a weekend, and the six things around it take months. One gateway for every model call with a spend cap per key, a fresh sandbox with no credentials for each task, hard caps on attempts and cost so stuck tasks go back to the board, traceability from line to session to commit to ticket to epic, prompt changes gated on test cases, and a human approving every merge. When a CTO asks whether to build in-house, the reply is to count how many of the six already exist. It's the most usable build-versus-buy checklist on the timeline this week.
#5
@deeponailabs
https://x.com/deeponailabs/status/2120897670533300299
deeponailabs breaks down a FAIR paper on routing agent memory across tasks. Instead of one global history or one compressed summary, a router sends each incoming instance to a cluster that owns one of five memory systems, and an adapter reads and updates only that cluster around the agent loop. Over 398 interleaved instances, normalized reward rose 15 to 30% of the attainable maximum against a single global history while estimated API cost fell 65 to 72%. The uncomfortable detail is that on one model a shared history scored below the stateless baseline, so memory can make an agent worse than having none.
https://x.com/deeponailabs/status/2120897670533300299
deeponailabs breaks down a FAIR paper on routing agent memory across tasks. Instead of one global history or one compressed summary, a router sends each incoming instance to a cluster that owns one of five memory systems, and an adapter reads and updates only that cluster around the agent loop. Over 398 interleaved instances, normalized reward rose 15 to 30% of the attainable maximum against a single global history while estimated API cost fell 65 to 72%. The uncomfortable detail is that on one model a shared history scored below the stateless baseline, so memory can make an agent worse than having none.
#6
@mzh1024
https://x.com/mzh1024/status/2121084801633726952
mzh1024 introduces SketchAgentBench, which gives a model a multimodal loop instead of a single prompt: render the scene, look at your own render, fix it. The finding is that the gap between models doesn't close when you add the loop, it widens. The verdict on the strongest coding models is great code, real taste and weak eyes. It's a useful counterweight to the one-shot 3D demos in every launch post, because a loop only helps as much as the model can see what it got wrong.
https://x.com/mzh1024/status/2121084801633726952
mzh1024 introduces SketchAgentBench, which gives a model a multimodal loop instead of a single prompt: render the scene, look at your own render, fix it. The finding is that the gap between models doesn't close when you add the loop, it widens. The verdict on the strongest coding models is great code, real taste and weak eyes. It's a useful counterweight to the one-shot 3D demos in every launch post, because a loop only helps as much as the model can see what it got wrong.
#7
@KissonL
https://x.com/KissonL/status/2121090811018318042
KissonL reads Vapi's launch of Agent Loop, a self-improving harness for voice agents, and is upfront that this is from the launch post, not hands-on use. The loop scores every call against a business goal, clusters the misses, drafts a fix with evidence and the exact diff, runs it through hundreds of simulated conversations, ships it to a slice of live traffic, and rolls back automatically if the number drops. The detail worth stealing is that lessons record decisions the business already made on purpose, so a fix can't quietly reintroduce them. The suggestion is to treat that locked list as a first-class check next to simulation and rollback, since a one-time diff review isn't enough when the agent can keep editing its own instructions.
https://x.com/KissonL/status/2121090811018318042
KissonL reads Vapi's launch of Agent Loop, a self-improving harness for voice agents, and is upfront that this is from the launch post, not hands-on use. The loop scores every call against a business goal, clusters the misses, drafts a fix with evidence and the exact diff, runs it through hundreds of simulated conversations, ships it to a slice of live traffic, and rolls back automatically if the number drops. The detail worth stealing is that lessons record decisions the business already made on purpose, so a fix can't quietly reintroduce them. The suggestion is to treat that locked list as a first-class check next to simulation and rollback, since a one-time diff review isn't enough when the agent can keep editing its own instructions.
#8
@HoodieFade_
https://x.com/HoodieFade_/status/2120909158538973342
HoodieFade_ compares five agent setups on a single question, which is who gets to say the work is done. Claude Code's Stop hook lets a script or a second model block the finish and send the reason back, LangGraph's interrupt() parks the graph until a person resumes it, Karpathy's autoresearch gives every run five minutes and lets val_bpb decide, Anthropic's long-running harness only counts a feature done when a passes flag flips after a user-style test, and gstack's /investigate stops after three failed fixes. The conclusion is that none of the strong setups let the agent that did the work declare it finished. That's the right axis for comparing harnesses, and almost nobody uses it.
https://x.com/HoodieFade_/status/2120909158538973342
HoodieFade_ compares five agent setups on a single question, which is who gets to say the work is done. Claude Code's Stop hook lets a script or a second model block the finish and send the reason back, LangGraph's interrupt() parks the graph until a person resumes it, Karpathy's autoresearch gives every run five minutes and lets val_bpb decide, Anthropic's long-running harness only counts a feature done when a passes flag flips after a user-style test, and gstack's /investigate stops after three failed fixes. The conclusion is that none of the strong setups let the agent that did the work declare it finished. That's the right axis for comparing harnesses, and almost nobody uses it.
#9
@stretchcloud
https://x.com/stretchcloud/status/2121113830902395024
stretchcloud looks at DeepSeek's open-source agent runtime, Harness, which runs on a plugin core called Cordis and has no privileged core at all: the model, the tool registry and even the agent loop are swappable through one config file. The part worth attention is the session model. Every model call becomes an append-only SessionEvent, so a session can be replayed or forked at any step like a git branch, which neither closed Claude Code nor monolithic Codex CLI offers. The bet is that the winning agent framework will be judged by whether its session log survives replay in front of an auditor, not by which model sits behind it.
https://x.com/stretchcloud/status/2121113830902395024
stretchcloud looks at DeepSeek's open-source agent runtime, Harness, which runs on a plugin core called Cordis and has no privileged core at all: the model, the tool registry and even the agent loop are swappable through one config file. The part worth attention is the session model. Every model call becomes an append-only SessionEvent, so a session can be replayed or forked at any step like a git branch, which neither closed Claude Code nor monolithic Codex CLI offers. The bet is that the winning agent framework will be judged by whether its session log survives replay in front of an auditor, not by which model sits behind it.
#10
@LabMutwil
https://x.com/LabMutwil/status/2121275158791061643
LabMutwil posts a map that aligns 5.6 million genes from 149 plant species, made with ESCAPE, a non-rigid alignment method that came out of the lab's own autoresearch loop. In the map, flowering plants merge into one shared core while ferns, lycophytes and mosses keep their own islands. The thread lets readers compare ESCAPE against the earlier ORBIT and THESEUS methods. This is autoresearch producing a method that biologists then use, which is a different and more durable output than a better score on a leaderboard.
https://x.com/LabMutwil/status/2121275158791061643
LabMutwil posts a map that aligns 5.6 million genes from 149 plant species, made with ESCAPE, a non-rigid alignment method that came out of the lab's own autoresearch loop. In the map, flowering plants merge into one shared core while ferns, lycophytes and mosses keep their own islands. The thread lets readers compare ESCAPE against the earlier ORBIT and THESEUS methods. This is autoresearch producing a method that biologists then use, which is a different and more durable output than a better score on a leaderboard.
#11
@yanchenhuang02
https://x.com/yanchenhuang02/status/2120847085184733539
yanchenhuang02 puts the limit of autoresearch in two sentences: it works when there's a metric to hill-climb, and most real research doesn't have one. Agents can run the experiments, but the bottleneck is the idea, and nobody can score an idea before it's tested. The post links months of the team's attempts at that problem. It's the clearest statement this week of why the loop keeps landing on kernels, compaction and benchmarks, which are the places where the metric already exists.
https://x.com/yanchenhuang02/status/2120847085184733539
yanchenhuang02 puts the limit of autoresearch in two sentences: it works when there's a metric to hill-climb, and most real research doesn't have one. Agents can run the experiments, but the bottleneck is the idea, and nobody can score an idea before it's tested. The post links months of the team's attempts at that problem. It's the clearest statement this week of why the loop keeps landing on kernels, compaction and benchmarks, which are the places where the metric already exists.
#12
@sayshrey
https://x.com/sayshrey/status/2121102752181043624
sayshrey shares results from the Autoresearch Exam benchmark showing that almost every model explores fewer than two idea basins before settling. In practice, the loop keeps polishing a variation of its first idea instead of trying a genuinely different approach, which caps what autoresearch can find. That gives a number to the complaint that agents hill-climb well but pick the hill badly. Anyone running long loops should measure exploration separately from the final score.
https://x.com/sayshrey/status/2121102752181043624
sayshrey shares results from the Autoresearch Exam benchmark showing that almost every model explores fewer than two idea basins before settling. In practice, the loop keeps polishing a variation of its first idea instead of trying a genuinely different approach, which caps what autoresearch can find. That gives a number to the complaint that agents hill-climb well but pick the hill badly. Anyone running long loops should measure exploration separately from the final score.
#13
@luca_zanolini
https://x.com/luca_zanolini/status/2121132497081921724
luca_zanolini announces a paper with levduc called Who Moved the Frontier, about how open challenges should pay out once AI agents can improve code, proofs and models on their own. The question it asks is how a challenge should pay when anyone can join under free identities, so one operator can show up as many entrants. That turns credit for agent-driven progress into a mechanism-design problem rather than a leaderboard. As bounties like the integer multiplication and kernel challenges multiply, who gets paid for moving the frontier becomes a real design problem.
https://x.com/luca_zanolini/status/2121132497081921724
luca_zanolini announces a paper with levduc called Who Moved the Frontier, about how open challenges should pay out once AI agents can improve code, proofs and models on their own. The question it asks is how a challenge should pay when anyone can join under free identities, so one operator can show up as many entrants. That turns credit for agent-driven progress into a mechanism-design problem rather than a leaderboard. As bounties like the integer multiplication and kernel challenges multiply, who gets paid for moving the frontier becomes a real design problem.
#14
@defaiscope
https://x.com/defaiscope/status/2120914768970027381
defaiscope quotes Isomorphic Labs president Max Jaderberg on how the job changed. AI researchers there no longer propose and implement one model change at a time, they define the design space of changes and the goals, and auto-research runs inside it. Chemists made the same move: instead of redrawing atoms on a whiteboard, a drug designer sets the design space and objectives for the next round, and design agents produce the individual molecules. It's one of the few first-hand descriptions from a lab of what the human role becomes once the loop runs, which is writing the objective.
https://x.com/defaiscope/status/2120914768970027381
defaiscope quotes Isomorphic Labs president Max Jaderberg on how the job changed. AI researchers there no longer propose and implement one model change at a time, they define the design space of changes and the goals, and auto-research runs inside it. Chemists made the same move: instead of redrawing atoms on a whiteboard, a drug designer sets the design space and objectives for the next round, and design agents produce the individual molecules. It's one of the few first-hand descriptions from a lab of what the human role becomes once the loop runs, which is writing the objective.
#15
@tcoratger
https://x.com/tcoratger/status/2120998758125096974
tcoratger flags that the Ethereum Foundation is running an auto-research competition to implement the EVM directly in RISC-V assembly, proven end to end with AI agents. The goal is to remove the compiler from the trusted computing base, so there's no Rust, no C and no translation bugs, just assembly and proofs. It's a good fit for the method, because correctness is checked by a proof and speed can be measured. Expect more infrastructure bounties shaped like this, where a formal check stands in for the human reviewer.
https://x.com/tcoratger/status/2120998758125096974
tcoratger flags that the Ethereum Foundation is running an auto-research competition to implement the EVM directly in RISC-V assembly, proven end to end with AI agents. The goal is to remove the compiler from the trusted computing base, so there's no Rust, no C and no translation bugs, just assembly and proofs. It's a good fit for the method, because correctness is checked by a proof and speed can be measured. Expect more infrastructure bounties shaped like this, where a formal check stands in for the human reviewer.
#16
@hammer_mt
https://x.com/hammer_mt/status/2121346769418440723
hammer_mt is trying what they call map-driven autoresearch. First map out every idea worth pursuing, then let Claude pick which ones get experiments, run ordinary autoresearch inside each chosen thread, and finally update the map and move resources between paths based on what was learned. It's a small, direct response to the idea-basin problem, because the map forces exploration across branches before any one branch gets polished. It's also cheap to copy on top of an existing loop.
https://x.com/hammer_mt/status/2121346769418440723
hammer_mt is trying what they call map-driven autoresearch. First map out every idea worth pursuing, then let Claude pick which ones get experiments, run ordinary autoresearch inside each chosen thread, and finally update the map and move resources between paths based on what was learned. It's a small, direct response to the idea-basin problem, because the map forces exploration across branches before any one branch gets polished. It's also cheap to copy on top of an existing loop.
#17
@omarsar0
https://x.com/omarsar0/status/2120930846714560533
omarsar0 calls human attention the scarcest resource in agentic coding and points to Expo Simulators, which lets a coding agent test its change on a cloud iOS Simulator and send back screenshots and a recording before asking for review. Anyone on the team can open the new build from a link and tap through it. The same day juwwwan described it as the last piece needed to let agents verify native apps end to end. Verification inside the loop is what lets a person review once instead of babysitting every step.
https://x.com/omarsar0/status/2120930846714560533
omarsar0 calls human attention the scarcest resource in agentic coding and points to Expo Simulators, which lets a coding agent test its change on a cloud iOS Simulator and send back screenshots and a recording before asking for review. Anyone on the team can open the new build from a link and tap through it. The same day juwwwan described it as the last piece needed to let agents verify native apps end to end. Verification inside the loop is what lets a person review once instead of babysitting every step.
#18
@afterxleep
https://x.com/afterxleep/status/2120931927922233357
afterxleep runs an agentic loop that's only allowed to find one bug per day. It proposes a fix and opens a PR, and that PR is the first thing checked each morning. Asking for every bug at once would sink the day into triage and ops instead of building. Rate-limiting the agent to match how much review a person can absorb is an underrated design choice, and it's the opposite of the 100-agents-overnight pitch.
https://x.com/afterxleep/status/2120931927922233357
afterxleep runs an agentic loop that's only allowed to find one bug per day. It proposes a fix and opens a PR, and that PR is the first thing checked each morning. Asking for every bug at once would sink the day into triage and ops instead of building. Rate-limiting the agent to match how much review a person can absorb is an underrated design choice, and it's the opposite of the 100-agents-overnight pitch.
#19
@scan33scan33
https://x.com/scan33scan33/status/2121305886266384633
scan33scan33 brings two lessons from search and recsys work with evolutionary loops. The loop is only as fast as its eval, and the agent will exploit eval bugs: a run that had diverged, with every score tied, still posted a near-top AUC. The fix was a tie-corrected AUC that also runs about 2,300 times faster than sklearn. It's a concrete case of the judge being the weak point, and a reminder to test the scorer against degenerate outputs before trusting a loop's results.
https://x.com/scan33scan33/status/2121305886266384633
scan33scan33 brings two lessons from search and recsys work with evolutionary loops. The loop is only as fast as its eval, and the agent will exploit eval bugs: a run that had diverged, with every score tied, still posted a near-top AUC. The fix was a tie-corrected AUC that also runs about 2,300 times faster than sklearn. It's a concrete case of the judge being the weak point, and a reminder to test the scorer against degenerate outputs before trusting a loop's results.
#20
@nathanz3491
https://x.com/nathanz3491/status/2121245856267641100
nathanz3491 reports what bit them running DreamerV3 on Craftax: the same agent with different seeds ended up to 1.8 achievements apart, and rescoring one checkpoint on 30 fresh worlds moved it by plus or minus 0.55. For an autoresearch benchmark, that noise is larger than many of the improvements a loop would keep. The suggestion is fixed eval worlds plus paired comparisons. If the noise floor is unmeasured, a keep-if-better loop mostly ratchets on luck.
https://x.com/nathanz3491/status/2121245856267641100
nathanz3491 reports what bit them running DreamerV3 on Craftax: the same agent with different seeds ended up to 1.8 achievements apart, and rescoring one checkpoint on 30 fresh worlds moved it by plus or minus 0.55. For an autoresearch benchmark, that noise is larger than many of the improvements a loop would keep. The suggestion is fixed eval worlds plus paired comparisons. If the noise floor is unmeasured, a keep-if-better loop mostly ratchets on luck.
#21
@KelvinPraises
https://x.com/KelvinPraises/status/2121191431834366352
KelvinPraises describes a documentation-constrained agentic loop that runs for weeks before the build starts. The approach is to collect reference repos with exemplary structure, spike up to three throwaway MVPs, then have a documentation agent spec every feature and state until the docs are a lossless compression of the project, and turn open items into clustered todos with explicit done-when lists. The build uses Claude Code's cross-session messaging with three forked agents: Fable 5.2 on low as a master that reviews each finished cluster, Opus 5.5 on medium as a manager that commits and answers questions, and Opus 5.5 on low as the worker. With that plan in place, the loop runs through the checklist largely hands-off.
https://x.com/KelvinPraises/status/2121191431834366352
KelvinPraises describes a documentation-constrained agentic loop that runs for weeks before the build starts. The approach is to collect reference repos with exemplary structure, spike up to three throwaway MVPs, then have a documentation agent spec every feature and state until the docs are a lossless compression of the project, and turn open items into clustered todos with explicit done-when lists. The build uses Claude Code's cross-session messaging with three forked agents: Fable 5.2 on low as a master that reviews each finished cluster, Opus 5.5 on medium as a manager that commits and answers questions, and Opus 5.5 on low as the worker. With that plan in place, the loop runs through the checklist largely hands-off.
#22
@LeoKharon
https://x.com/LeoKharon/status/2120985628007342306
LeoKharon covers RoboSkills, a pip-installable package from OpenRoboKit that bundles five agent workflows for robotics, each held under 1,000 lines. The first is auto research, where an agent runs repeated simulation experiments to improve a policy and then freezes it, and the others cover agent-as-policy, agentic simulation, Real2Sim scene rebuilding from video, and motion generation. Thirteen tools sit underneath, including MuJoCo, Blender, SAM 3 and NVIDIA's Kimodo, all running in simulation. The caveat is spelled out too: there's no paper, no author list and no hardware yet.
https://x.com/LeoKharon/status/2120985628007342306
LeoKharon covers RoboSkills, a pip-installable package from OpenRoboKit that bundles five agent workflows for robotics, each held under 1,000 lines. The first is auto research, where an agent runs repeated simulation experiments to improve a policy and then freezes it, and the others cover agent-as-policy, agentic simulation, Real2Sim scene rebuilding from video, and motion generation. Thirteen tools sit underneath, including MuJoCo, Blender, SAM 3 and NVIDIA's Kimodo, all running in simulation. The caveat is spelled out too: there's no paper, no author list and no hardware yet.
#23
@Khaled865412521
https://x.com/Khaled865412521/status/2121366541006463222
Khaled865412521 walks through OpenWorker Harness SDK, a new open-source, model-agnostic kit from Andrew Ng for building an agent harness. The quickest way in is to let a coding agent scaffold it with one npx command for Claude or Codex, then ask for something concrete, like a file organizer locked to one folder that asks before every move. The SDK takes over the agent loop, model calls, approvals and durable sessions, while the app keeps its own UI, auth, tools and policies. Under the hood is a Rust engine with TypeScript and Rust SDKs, and it's flagged as under active development.
https://x.com/Khaled865412521/status/2121366541006463222
Khaled865412521 walks through OpenWorker Harness SDK, a new open-source, model-agnostic kit from Andrew Ng for building an agent harness. The quickest way in is to let a coding agent scaffold it with one npx command for Claude or Codex, then ask for something concrete, like a file organizer locked to one folder that asks before every move. The SDK takes over the agent loop, model calls, approvals and durable sessions, while the app keeps its own UI, auth, tools and policies. Under the hood is a Rust engine with TypeScript and Rust SDKs, and it's flagged as under active development.
#24
@SteveGalvisX
https://x.com/SteveGalvisX/status/2120841541606613356
SteveGalvisX hit a failure nobody plans for: an agent loop running on a VPS with a Codex subscription got signed out mid-run. The saved login was still on disk but no longer worked, so the loop sat stuck until a person signed in again. Auth expiry is a mundane way for an overnight loop to stall, and it won't show up in any benchmark. It belongs on the checklist next to spend caps and stop rules.
https://x.com/SteveGalvisX/status/2120841541606613356
SteveGalvisX hit a failure nobody plans for: an agent loop running on a VPS with a Codex subscription got signed out mid-run. The saved login was still on disk but no longer worked, so the loop sat stuck until a person signed in again. Auth expiry is a mundane way for an overnight loop to stall, and it won't show up in any benchmark. It belongs on the checklist next to spend caps and stop rules.
#25
@yuntan4
https://x.com/yuntan4/status/2120681098175029589
yuntan4 prices an honest $40 a month coding stack. Claude Pro at $20 is called the best agentic loop available, until the five-hour rolling limit kills a long refactor mid-job, and ChatGPT Plus at $20 runs Codex as overflow for exactly that moment. Two $20 plans that cover each other's failure mode beat one $40 plan with a single point of failure. For long loops, the usage window has become an architecture constraint, not just a billing detail.
https://x.com/yuntan4/status/2120681098175029589
yuntan4 prices an honest $40 a month coding stack. Claude Pro at $20 is called the best agentic loop available, until the five-hour rolling limit kills a long refactor mid-job, and ChatGPT Plus at $20 runs Codex as overflow for exactly that moment. Two $20 plans that cover each other's failure mode beat one $40 plan with a single point of failure. For long loops, the usage window has become an architecture constraint, not just a billing detail.
#26
@soljaxonp
https://x.com/soljaxonp/status/2121364855034954102
soljaxonp shares the loop used on a benchmark project. Fable 5.2 reads the bench as a baseline to spot issues, forms a hypothesis about the cause, has sub-agents implement a fix based on that hypothesis, ships it to a runner rather than production, runs the experiment, and checks whether the hypothesis held. The cycle repeats until returns diminish. The detail that matters is that the hypothesis is written down before the fix, so a result can actually prove the model wrong.
https://x.com/soljaxonp/status/2121364855034954102
soljaxonp shares the loop used on a benchmark project. Fable 5.2 reads the bench as a baseline to spot issues, forms a hypothesis about the cause, has sub-agents implement a fix based on that hypothesis, ships it to a runner rather than production, runs the experiment, and checks whether the hypothesis held. The cycle repeats until returns diminish. The detail that matters is that the hypothesis is written down before the fix, so a result can actually prove the model wrong.
#27
@AntifragileFR
https://x.com/AntifragileFR/status/2121189339187085315
AntifragileFR built setup-autoresearch, a skill inspired by Karpathy's autoresearch that creates every artifact needed to run an autoresearch loop on a new target. The examples are concrete engineering metrics, like optimizing response time for a request or Docker cold start, and then letting the model iterate. Packaging the setup is useful because the hard part of autoresearch is usually wiring the metric, the budget and the revert rule, not the loop itself.
https://x.com/AntifragileFR/status/2121189339187085315
AntifragileFR built setup-autoresearch, a skill inspired by Karpathy's autoresearch that creates every artifact needed to run an autoresearch loop on a new target. The examples are concrete engineering metrics, like optimizing response time for a request or Docker cold start, and then letting the model iterate. Packaging the setup is useful because the hard part of autoresearch is usually wiring the metric, the budget and the revert rule, not the loop itself.
#28
@walkthegrowth
https://x.com/walkthegrowth/status/2120823294488141845
walkthegrowth released agent-seed under MIT, a tiny framework-agnostic agentic loop meant to fit in one person's head. It has a REPL, a tool-calling loop, behaviors added as plain Python hooks, no SDK, and it works with any OpenAI-compatible endpoint, so an agent becomes a folder with voice, tools and rules. It was built with Qweenie 3.8 and is pitched as a seed rather than a product. Small readable loops like this are the best way to learn what the bigger harnesses are doing.
https://x.com/walkthegrowth/status/2120823294488141845
walkthegrowth released agent-seed under MIT, a tiny framework-agnostic agentic loop meant to fit in one person's head. It has a REPL, a tool-calling loop, behaviors added as plain Python hooks, no SDK, and it works with any OpenAI-compatible endpoint, so an agent becomes a folder with voice, tools and rules. It was built with Qweenie 3.8 and is pitched as a seed rather than a product. Small readable loops like this are the best way to learn what the bigger harnesses are doing.
π‘ Eco Products Radar
Eco Products Radar
Karpathy's autoresearch: still the reference loop, cited in a flood of repo-list threads and in real builds such as setup-autoresearch and map-driven autoresearch.
Claude Code: Stop hooks, cross-session messaging and Code Mode came up as the parts people actually build loops on.
Fable 5.2: the planner or master agent in several multi-agent setups, usually paired with cheaper workers.
Opus 5.5: the default worker and manager model in the same setups.
Kosmos: Edison's research agent, now running its own compaction research end to end.
LangGraph: the usual answer for pausing a loop for human approval with interrupt().
Claude Agent SDK: the standard way people build their own agent loop in Python.
Hermes: Nous Research's self-improving agent, mostly mentioned in reply threads comparing agent frameworks.
Karpathy's autoresearch: still the reference loop, cited in a flood of repo-list threads and in real builds such as setup-autoresearch and map-driven autoresearch.
Claude Code: Stop hooks, cross-session messaging and Code Mode came up as the parts people actually build loops on.
Fable 5.2: the planner or master agent in several multi-agent setups, usually paired with cheaper workers.
Opus 5.5: the default worker and manager model in the same setups.
Kosmos: Edison's research agent, now running its own compaction research end to end.
LangGraph: the usual answer for pausing a loop for human approval with interrupt().
Claude Agent SDK: the standard way people build their own agent loop in Python.
Hermes: Nous Research's self-improving agent, mostly mentioned in reply threads comparing agent frameworks.
Comments