Loop Daily: 2026-09-25
The loop stopped being a demo today and started being infrastructure with a price tag. An open benchmark for recursive self-improvement shipped with 60-hour agent trajectories on a thousand GPUs and named what two agents actually discovered β Codex found an optimizer that balances matrix updates across directions, Claude Code found one that scales each hidden unit's update relative to its weights, for 0.60% and 0.35% over the baseline. A bounty challenge cut the cost of a post-quantum Bitcoin transaction 79% in seven days. Perplexity attributed a core retrieval engine to hundreds of auto-research loops rather than to engineers. Underneath the wins sits a much harder finding: Google's paper shows that auto-optimizing a harness makes your eval score rise while the agent gets worse on real tasks, and the fix is regularizing both ends of the loop. The other half of today is the sober half β the bottleneck is not the agent loop, it is the supervision loop, and the people who ship audit trails before autonomy are the ones whose pilots survive. The single most quoted architectural claim of the day: do not run the agent inside the sandbox, because the sandbox's blast radius becomes your agent's blast radius.
#1
@OpenRSI
https://x.com/OpenRSI/status/2102831770458890626
Released OpenRSI-Index v0.1, an open benchmark for whether an AI can recursively improve itself on production-scale clusters rather than on toy tasks. They turn fully open-source projects into autoresearch environments with agent trajectories lasting 60-plus hours, run them on 1,000 GPUs, and building v0.1 alone took over 100,000 H100-hours. The framing is the part worth arguing with: they claim the central question is whether recursive self-improvement can systematically move beyond human-designed methods, and that what is missing is a neutral open standard for measuring it in real intelligence development rather than a leaderboard row.
https://x.com/OpenRSI/status/2102831770458890626
Released OpenRSI-Index v0.1, an open benchmark for whether an AI can recursively improve itself on production-scale clusters rather than on toy tasks. They turn fully open-source projects into autoresearch environments with agent trajectories lasting 60-plus hours, run them on 1,000 GPUs, and building v0.1 alone took over 100,000 H100-hours. The framing is the part worth arguing with: they claim the central question is whether recursive self-improvement can systematically move beyond human-designed methods, and that what is missing is a neutral open standard for measuring it in real intelligence development rather than a leaderboard row.
#2
@yuetai12575
https://x.com/yuetai12575/status/2102884893562941492
Explained why they built RSI-Anything as a human-AI collaboration pipeline: through about one hour of conversation it turns a real research question into a runnable autoresearch environment. His argument for opening it is that today everyone is excited about recursive self-improvement while the barriers to participation keep everyone outside the door, and that a model's RSI capability comes from researchers, independent labs and domain teams alike. Everything ships open including the traces: tasks, harnesses, verifiers and full agent trajectories. The line worth keeping is that human insights are limited by bandwidth while agents can sweep a far larger region of method-space.
https://x.com/yuetai12575/status/2102884893562941492
Explained why they built RSI-Anything as a human-AI collaboration pipeline: through about one hour of conversation it turns a real research question into a runnable autoresearch environment. His argument for opening it is that today everyone is excited about recursive self-improvement while the barriers to participation keep everyone outside the door, and that a model's RSI capability comes from researchers, independent labs and domain teams alike. Everything ships open including the traces: tasks, harnesses, verifiers and full agent trajectories. The line worth keeping is that human insights are limited by bandwidth while agents can sweep a far larger region of method-space.
#3
@OpenRSI
https://x.com/OpenRSI/status/2102831775307411720
Posted the first concrete results, which are the most interesting thing in this feed today because they name what each agent actually discovered. On Marin-Scaling-Ladder, agents have to autonomously propose, implement and evaluate new optimizers across six model scales from 550M to 2.5B against the Marin baseline. Codex on GPT-5.6 tested 17 hypotheses and discovered PSPR, which balances the strength of matrix updates across directions, for a 0.60% average improvement over AdamH across all six rungs. Claude Code on Opus 5 discovered RMBT, which scales each hidden unit's update relative to its weights, for 0.35%. Small numbers, but they are optimizer discoveries, not prompt tweaks.
https://x.com/OpenRSI/status/2102831775307411720
Posted the first concrete results, which are the most interesting thing in this feed today because they name what each agent actually discovered. On Marin-Scaling-Ladder, agents have to autonomously propose, implement and evaluate new optimizers across six model scales from 550M to 2.5B against the Marin baseline. Codex on GPT-5.6 tested 17 hypotheses and discovered PSPR, which balances the strength of matrix updates across directions, for a 0.60% average improvement over AdamH across all six rungs. Claude Code on Opus 5 discovered RMBT, which scales each hidden unit's update relative to its weights, for 0.35%. Small numbers, but they are optimizer discoveries, not prompt tweaks.
#4
@StarkWareLtd
https://x.com/StarkWareLtd/status/2103137679940505957
One week into their Quantum-Safe Bitcoin Autoresearch Challenge, researchers and AI agents pushed the cost of a post-quantum secure Bitcoin transaction from about $320 to about $67, a 79% reduction in seven days. The top three contributors from week one split $2,000 and $18,000 remains over the next two weeks. This is the cleanest example this window of an autoresearch loop pointed at a single scalar that has real money attached β the objective is verifiable, the leaderboard is public, and the reward is denominated in dollars rather than citations.
https://x.com/StarkWareLtd/status/2103137679940505957
One week into their Quantum-Safe Bitcoin Autoresearch Challenge, researchers and AI agents pushed the cost of a post-quantum secure Bitcoin transaction from about $320 to about $67, a 79% reduction in seven days. The top three contributors from week one split $2,000 and $18,000 remains over the next two weeks. This is the cleanest example this window of an autoresearch loop pointed at a single scalar that has real money attached β the objective is verifiable, the leaderboard is public, and the reward is denominated in dollars rather than citations.
#5
@VoidAsuka
https://x.com/VoidAsuka/status/2102995589017543102
Wrote up a first pull request made on rented H100s through a GPU platform now called Autoresearch, and the detail that matters is what the agent did rather than what the model was. She used to write and maintain a lot of scripts to use rented compute efficiently; here her coding agent could create nodes, run the container, inspect failures, retrieve results and shut the node down when it was no longer needed, all in the same workflow as editing code. The patch itself fixes a Diffusers version overriding a deterministic setting and wrapping FA3 in a custom op without a registered backward. GPU charges for the whole validation, including setup and retries, came to about $8.
https://x.com/VoidAsuka/status/2102995589017543102
Wrote up a first pull request made on rented H100s through a GPU platform now called Autoresearch, and the detail that matters is what the agent did rather than what the model was. She used to write and maintain a lot of scripts to use rented compute efficiently; here her coding agent could create nodes, run the container, inspect failures, retrieve results and shut the node down when it was no longer needed, all in the same workflow as editing code. The patch itself fixes a Diffusers version overriding a deterministic setting and wrapping FA3 in a custom op without a registered backward. GPU charges for the whole validation, including setup and retries, came to about $8.
#6
@AravSrinivas
https://x.com/AravSrinivas/status/2103195385804238972
Says Perplexity's Rust-based retrieval and ranking engine Photon, which hits sub-250ms p95 latency while ranking highly on relevance benchmarks, was built by a small team and hundreds of auto-research loops powered by a more capable internal version of Perplexity Computer. The forward claim is the load-bearing one: the loops will keep hill-climbing on the Pareto frontier. This is the first time a major consumer AI product has attributed a core infrastructure component to an auto-research process in public rather than to engineers.
https://x.com/AravSrinivas/status/2103195385804238972
Says Perplexity's Rust-based retrieval and ranking engine Photon, which hits sub-250ms p95 latency while ranking highly on relevance benchmarks, was built by a small team and hundreds of auto-research loops powered by a more capable internal version of Perplexity Computer. The forward claim is the load-bearing one: the loops will keep hill-climbing on the Pareto frontier. This is the first time a major consumer AI product has attributed a core infrastructure component to an auto-research process in public rather than to engineers.
#7
@GregKamradt
https://x.com/GregKamradt/status/2102783480191189236
Cut through the RSI argument with two requirements. First, models have to generate ideas that improve the model β but there is a big difference between optimization improvements of the nanoGPT kind and fundamental ones like alternative architectures, and AI is currently much better at the former. Second, humans have to come out of the loop, and right now a human still clicks deploy; removing that bottleneck speeds up cycle time but also removes oversight, which he treats as a trust and engineering problem that gets fixed with better monitoring and interpretability. His side note is the sharpest line in the thread: RSI is already here, because putting a local model on an autoresearch loop to improve itself or another model is RSI β it is just not very good yet, which is why everyone is arguing about degree.
https://x.com/GregKamradt/status/2102783480191189236
Cut through the RSI argument with two requirements. First, models have to generate ideas that improve the model β but there is a big difference between optimization improvements of the nanoGPT kind and fundamental ones like alternative architectures, and AI is currently much better at the former. Second, humans have to come out of the loop, and right now a human still clicks deploy; removing that bottleneck speeds up cycle time but also removes oversight, which he treats as a trust and engineering problem that gets fixed with better monitoring and interpretability. His side note is the sharpest line in the thread: RSI is already here, because putting a local model on an autoresearch loop to improve itself or another model is RSI β it is just not very good yet, which is why everyone is arguing about degree.
#8
@realbarnakiss
https://x.com/realbarnakiss/status/2102780148906909934
Described what long autoresearch actually feels like from the inside. When you find the right problem that takes weeks to solve with AI, you enter a loop of knowledge acquisition where you keep looking back at your understanding from three or four days ago and realising how much you did not know β and knowing you will know much more in another three or four days. His explanation for why the disconnect between people is so large is the interesting part: the definition of knowledge itself changes, in terms of what is required, what is unnecessary, and what looks skippable but is not.
https://x.com/realbarnakiss/status/2102780148906909934
Described what long autoresearch actually feels like from the inside. When you find the right problem that takes weeks to solve with AI, you enter a loop of knowledge acquisition where you keep looking back at your understanding from three or four days ago and realising how much you did not know β and knowing you will know much more in another three or four days. His explanation for why the disconnect between people is so large is the interesting part: the definition of knowledge itself changes, in terms of what is required, what is unnecessary, and what looks skippable but is not.
#9
@dair_ai
https://x.com/dair_ai/status/2102465468556820660
Summarised PrimeScientist, which treats deciding where a research agent spends its budget as part of the agent's job rather than as a hyperparameter. It keeps an executable plan tree of competing research directions and their outcomes, and an adaptive MCTS policy reads experimental feedback plus remaining budget to choose whether to explore a new direction or continue a promising one. Against AutoResearch on 12 AI research tasks under the same budget it achieved 10.3% more reward with 50.6% fewer research attempts, and the gains hold on systems, code optimization and ML engineering tasks. The line that makes it actionable: if your research agent can propose more experiments than you can afford to run, this is a concrete method for choosing among them.
https://x.com/dair_ai/status/2102465468556820660
Summarised PrimeScientist, which treats deciding where a research agent spends its budget as part of the agent's job rather than as a hyperparameter. It keeps an executable plan tree of competing research directions and their outcomes, and an adaptive MCTS policy reads experimental feedback plus remaining budget to choose whether to explore a new direction or continue a promising one. Against AutoResearch on 12 AI research tasks under the same budget it achieved 10.3% more reward with 50.6% fewer research attempts, and the gains hold on systems, code optimization and ML engineering tasks. The line that makes it actionable: if your research agent can propose more experiments than you can afford to run, this is a concrete method for choosing among them.
#10
@pzakin
https://x.com/pzakin/status/2102477549024706842
Laid out five categories of company he is looking for, and the first one reframes autoresearch usefully. He calls them explorer agents β agents that continuously investigate the search space of possible improvements β and says autoresearch is one example of an explorer with a verifiable objective, while he expects interesting explorers to be found with non-verifiable objectives too. His simple description: an agent that overthinks the hell out of something. He also wants sensors and sims because good decisions come from understanding how the world works, and argues every software product should leverage autonomous loops driven by data collected in sim or at production time.
https://x.com/pzakin/status/2102477549024706842
Laid out five categories of company he is looking for, and the first one reframes autoresearch usefully. He calls them explorer agents β agents that continuously investigate the search space of possible improvements β and says autoresearch is one example of an explorer with a verifiable objective, while he expects interesting explorers to be found with non-verifiable objectives too. His simple description: an agent that overthinks the hell out of something. He also wants sensors and sims because good decisions come from understanding how the world works, and argues every software product should leverage autonomous loops driven by data collected in sim or at production time.
#11
@varun_mathur
https://x.com/varun_mathur/status/2102463188432216202
Got cited in an academic paper for work on how agentic swarms came to collaborate without an orchestrator, and the lineage he describes is worth recording. After Karpathy asked people to consider a SETI-at-home style collaborative effort for the autoresearch loop he had pioneered, he built it without a central orchestrator, using a message board instead. The key features: agents reading and writing a shared public record, open participation, signature-scoped branches, a CRDT leaderboard, and gossip broadcasts of all results including non-improvements. His claim is that this is the shape every swarm since March 2026 has converged on β and that broadcasting the failures, not just the wins, is what makes agentic knowledge compound.
https://x.com/varun_mathur/status/2102463188432216202
Got cited in an academic paper for work on how agentic swarms came to collaborate without an orchestrator, and the lineage he describes is worth recording. After Karpathy asked people to consider a SETI-at-home style collaborative effort for the autoresearch loop he had pioneered, he built it without a central orchestrator, using a message board instead. The key features: agents reading and writing a shared public record, open participation, signature-scoped branches, a CRDT leaderboard, and gossip broadcasts of all results including non-improvements. His claim is that this is the shape every swarm since March 2026 has converged on β and that broadcasting the failures, not just the wins, is what makes agentic knowledge compound.
#12
@EMostaque
https://x.com/EMostaque/status/2102810115703484479
Points at the Bespoke Labs blog post on the Autoresearch exam, which shows minimal difference in performance with standard harnesses. That is a quietly important negative result in a week where everyone is selling harness optimization: if a purpose-built research setup performs about the same as a stock one on this exam, then the harness gains people are reporting elsewhere are task-specific rather than general. His read is that a reliable frontier is within reach for everyone.
https://x.com/EMostaque/status/2102810115703484479
Points at the Bespoke Labs blog post on the Autoresearch exam, which shows minimal difference in performance with standard harnesses. That is a quietly important negative result in a week where everyone is selling harness optimization: if a purpose-built research setup performs about the same as a stock one on this exam, then the harness gains people are reporting elsewhere are task-specific rather than general. His read is that a reliable frontier is within reach for everyone.
#13
@antoine_chaffin
https://x.com/antoine_chaffin/status/2102290426589819092
One sentence, and it is the most quietly radical thing in the batch: discussing with your CTO about auto-research training an encoder over the weekend. Not a demo, not a benchmark β a routine engineering conversation in which an unattended weekend training run is now the assumed default for a component nobody would have staffed a person to tune.
https://x.com/antoine_chaffin/status/2102290426589819092
One sentence, and it is the most quietly radical thing in the batch: discussing with your CTO about auto-research training an encoder over the weekend. Not a demo, not a benchmark β a routine engineering conversation in which an unattended weekend training run is now the assumed default for a component nobody would have staffed a person to tune.
#14
@insecureagents
https://x.com/insecureagents/status/2102391446674554993
Published an interview with Cotool's CEO on agentic defense that contains the most honest line about autonomy this window: there is a lot of marketing noise saying take the human out of the loop, and they have seen very few people hit that run phase. The staged approach is crawl, walk, run β read only, then an approval hook in Slack or Teams, then counting how often the agent was right. Two specifics stand out: one blocker is whether the agent knows at runtime that the server it is about to kill powers a million dollars a day, and the audit log has to capture each agent action and whether it acted on someone's behalf. They grant API access at config time rather than run time, and they are watching for agent number 17 of 40 starting to drift. Next up for them is auto-research loops and digital twins.
https://x.com/insecureagents/status/2102391446674554993
Published an interview with Cotool's CEO on agentic defense that contains the most honest line about autonomy this window: there is a lot of marketing noise saying take the human out of the loop, and they have seen very few people hit that run phase. The staged approach is crawl, walk, run β read only, then an approval hook in Slack or Teams, then counting how often the agent was right. Two specifics stand out: one blocker is whether the agent knows at runtime that the server it is about to kill powers a million dollars a day, and the audit log has to capture each agent action and whether it acted on someone's behalf. They grant API access at config time rather than run time, and they are watching for agent number 17 of 40 starting to drift. Next up for them is auto-research loops and digital twins.
#15
@alex_verem
https://x.com/alex_verem/status/2102698998515761629
Wrote the clearest summary of the NVIDIA, NTU and MIT SoL-Pi paper on self-improving agent harnesses. A research AI watched a coding agent work, proposed changes to the harness, tested them and kept only what saved tokens without hurting results β about 150 research directions across roughly 500 environments, more than 3,000 runs, over 60,000 agent-environment interactions. Four fixes survived: edit a file and run the test in one call instead of two; compress memory when a subtask finishes, and only if that is cheaper than keeping everything; send big tool outputs in full twice then swap for a 1KB excerpt with a handle to pull the rest; and have a cheap model summarize build and test logs with a verifier that rejects summaries dropping evidence. Token traffic dropped 44.7 to 49%, API cost by about a third, scores held at roughly 94%. None of it touches the model. Their next move: run the search again with the cheaper harness, so a cheaper agent funds the search for an even cheaper one.
https://x.com/alex_verem/status/2102698998515761629
Wrote the clearest summary of the NVIDIA, NTU and MIT SoL-Pi paper on self-improving agent harnesses. A research AI watched a coding agent work, proposed changes to the harness, tested them and kept only what saved tokens without hurting results β about 150 research directions across roughly 500 environments, more than 3,000 runs, over 60,000 agent-environment interactions. Four fixes survived: edit a file and run the test in one call instead of two; compress memory when a subtask finishes, and only if that is cheaper than keeping everything; send big tool outputs in full twice then swap for a 1KB excerpt with a handle to pull the rest; and have a cheap model summarize build and test logs with a verifier that rejects summaries dropping evidence. Token traffic dropped 44.7 to 49%, API cost by about a third, scores held at roughly 94%. None of it touches the model. Their next move: run the search again with the cheaper harness, so a cheaper agent funds the search for an even cheaper one.
#16
@ayyazdev
https://x.com/ayyazdev/status/2102883543479173512
Added the number that makes the SoL-Pi result land: the auto-research loop proposed 152 harness changes and four survived. That is a 2.6% survival rate, and it is the most useful statistic in the paper because it prices the loop honestly β the value is not that an AI proposes changes, it is that it can afford to propose 152 of them and throw away 148. He also notes the Evidence-Preserving Reducer ships fat build and test logs through a cheaper model with a verifier, and that his own takeaway is that a chunk of the bill is simply how the agent talks to tools.
https://x.com/ayyazdev/status/2102883543479173512
Added the number that makes the SoL-Pi result land: the auto-research loop proposed 152 harness changes and four survived. That is a 2.6% survival rate, and it is the most useful statistic in the paper because it prices the loop honestly β the value is not that an AI proposes changes, it is that it can afford to propose 152 of them and throw away 148. He also notes the Evidence-Preserving Reducer ships fat build and test logs through a cheaper model with a verifier, and that his own takeaway is that a chunk of the bill is simply how the agent talks to tools.
#17
@omarsar0
https://x.com/omarsar0/status/2102853768266256738
Summarised the Google paper that names the failure mode of every self-improving harness: if you auto-optimize your agent's harness, your eval score can go up while the agent gets worse on real tasks. Of five harness-evolution methods compared on agentic workspace tasks, the regularized one scored lowest on the tasks it evolved against and highest on all three out-of-distribution benchmarks. Meta-Harness reached 93.0 on the evolve split but gained only 0.3 to 1.5 points on JobBench, GDPval and APEX-Agents. RRSI adds regularization on both sides: the proposer gets a shrinking edit budget and is pushed toward untried directions, a critic rejects benchmark-specific edits, and a pruner removes edits that are too small, too costly or no longer useful. RRSI scored 90.5 on the evolve split and gained 3.5 to 4.7 points on the held-out benchmarks, using 2.42M tokens per trial against 3.80M unregularized.
https://x.com/omarsar0/status/2102853768266256738
Summarised the Google paper that names the failure mode of every self-improving harness: if you auto-optimize your agent's harness, your eval score can go up while the agent gets worse on real tasks. Of five harness-evolution methods compared on agentic workspace tasks, the regularized one scored lowest on the tasks it evolved against and highest on all three out-of-distribution benchmarks. Meta-Harness reached 93.0 on the evolve split but gained only 0.3 to 1.5 points on JobBench, GDPval and APEX-Agents. RRSI adds regularization on both sides: the proposer gets a shrinking edit budget and is pushed toward untried directions, a critic rejects benchmark-specific edits, and a pruner removes edits that are too small, too costly or no longer useful. RRSI scored 90.5 on the evolve split and gained 3.5 to 4.7 points on the held-out benchmarks, using 2.42M tokens per trial against 3.80M unregularized.
#18
@tierfour_
https://x.com/tierfour_/status/2102429476571288057
Relayed a distinction that reframes agent design: coding agents and tools agents are not the same thing. A tools agent dumps every result straight into the LLM context, so asking it to hit a database returns all the rows and all of it burns input tokens before the model even reasons. A code agent invokes plain functions and gets structured objects back β a DataFrame instead of a wall of text β which you can hand to the next step without ever copying that data through the model. The right mental model is a Jupyter notebook session, and one agent can wield both paradigms per task. Where it gets wild is auto-research: point it at a problem and it runs hundreds of experiments in a couple of days without fatigue, and the bottleneck stops being the scientist and becomes compute.
https://x.com/tierfour_/status/2102429476571288057
Relayed a distinction that reframes agent design: coding agents and tools agents are not the same thing. A tools agent dumps every result straight into the LLM context, so asking it to hit a database returns all the rows and all of it burns input tokens before the model even reasons. A code agent invokes plain functions and gets structured objects back β a DataFrame instead of a wall of text β which you can hand to the next step without ever copying that data through the model. The right mental model is a Jupyter notebook session, and one agent can wield both paradigms per task. Where it gets wild is auto-research: point it at a problem and it runs hundreds of experiments in a couple of days without fatigue, and the bottleneck stops being the scientist and becomes compute.
#19
@0xMortyx
https://x.com/0xMortyx/status/2102418994510639280
Built a self-improving agent that went from 12% to 88% success on a hostile checkout in 29 seconds for two cents, with zero fine-tuning β same agent, same model weights, 50 attempts. After every failure a decision model asks six typed questions: which step broke, what was the root cause, will it happen again or was it noise. Eight rules were kept and sixteen failures thrown away as noise. Two of the surviving rules were ignore the green BUY NOW banner, worth 16 points, and captcha means go to the audio challenge, worth 12. His conclusion is the one to take: the agent was never bad at checkout, it was bad at not clicking ads.
https://x.com/0xMortyx/status/2102418994510639280
Built a self-improving agent that went from 12% to 88% success on a hostile checkout in 29 seconds for two cents, with zero fine-tuning β same agent, same model weights, 50 attempts. After every failure a decision model asks six typed questions: which step broke, what was the root cause, will it happen again or was it noise. Eight rules were kept and sixteen failures thrown away as noise. Two of the surviving rules were ignore the green BUY NOW banner, worth 16 points, and captcha means go to the audio challenge, worth 12. His conclusion is the one to take: the agent was never bad at checkout, it was bad at not clicking ads.
#20
@JamesWard
https://x.com/JamesWard/status/2102468057494917237
Reports that in his decision-model-based agentic loop there are now only two places he needs an LLM as a tool: summarization and parameter parsing. He used to use the LLM to create filter criteria for items returned from tool calls, the way a coding assistant defines grep and find calls. Now he just has the decision model do the filtering directly β it cannot write filter criteria like an LLM, but for small enough datasets it can do the semantic filter itself, which he thinks is probably more accurate than generated criteria anyway.
https://x.com/JamesWard/status/2102468057494917237
Reports that in his decision-model-based agentic loop there are now only two places he needs an LLM as a tool: summarization and parameter parsing. He used to use the LLM to create filter criteria for items returned from tool calls, the way a coding assistant defines grep and find calls. Now he just has the decision model do the filtering directly β it cannot write filter criteria like an LLM, but for small enough datasets it can do the semantic filter itself, which he thinks is probably more accurate than generated criteria anyway.
#21
@OnFinality
https://x.com/OnFinality/status/2102413942824075551
Put his finger on where people actually stall when building agentic loops, in a reply asking whether a course covers it. The loop itself is easy; deciding when it should stop, retry, or hand back to a human is the part that eats the time. Termination conditions are the least taught and most expensive piece of loop engineering, and almost no material covers them.
https://x.com/OnFinality/status/2102413942824075551
Put his finger on where people actually stall when building agentic loops, in a reply asking whether a course covers it. The loop itself is easy; deciding when it should stop, retry, or hand back to a human is the part that eats the time. Termination conditions are the least taught and most expensive piece of loop engineering, and almost no material covers them.
#22
@NathanFlurry
https://x.com/NathanFlurry/status/2102523527304032256
Made the strongest architectural argument of the window against running agents inside the sandbox. It is simple in theory, but in production the sandbox's blast radius becomes your agent's blast radius: the sandbox crashes or OOMs and the agent loop dies with it; the disk fills or the environment breaks and the agent is bricked; exposing your own API as tools needs extra infra; credentials cannot live in the sandbox so you need a whole credential proxy layer; a sleeping sandbox cannot wake itself for crons; updating agent code means updating the binary in every VM; and monitoring means the sandbox has to report its own failures. His alternative: run the harness in your backend, expose the sandbox as tools, keep credentials, history and permissions outside, and wake the sandbox only when needed. He notes Amp, Vercel Eve, Cloudflare Flue, Claude Managed Agents and OpenAI's Agents SDK all converged on this.
https://x.com/NathanFlurry/status/2102523527304032256
Made the strongest architectural argument of the window against running agents inside the sandbox. It is simple in theory, but in production the sandbox's blast radius becomes your agent's blast radius: the sandbox crashes or OOMs and the agent loop dies with it; the disk fills or the environment breaks and the agent is bricked; exposing your own API as tools needs extra infra; credentials cannot live in the sandbox so you need a whole credential proxy layer; a sleeping sandbox cannot wake itself for crons; updating agent code means updating the binary in every VM; and monitoring means the sandbox has to report its own failures. His alternative: run the harness in your backend, expose the sandbox as tools, keep credentials, history and permissions outside, and wake the sandbox only when needed. He notes Amp, Vercel Eve, Cloudflare Flue, Claude Managed Agents and OpenAI's Agents SDK all converged on this.
#23
@Kizuno18
https://x.com/Kizuno18/status/2102206357017436609
Added the recovery argument that makes deterministic checkpointing worth the trouble: when each checkpoint is verified out-of-band by deterministic code, a 3am crash does not mean starting a 30-minute agent loop from scratch β you resume from the last passing checkpoint with guaranteed clean state. The phrase to keep is out-of-band. The verification cannot come from the same agent whose work it is checking, or the checkpoint proves nothing.
https://x.com/Kizuno18/status/2102206357017436609
Added the recovery argument that makes deterministic checkpointing worth the trouble: when each checkpoint is verified out-of-band by deterministic code, a 3am crash does not mean starting a 30-minute agent loop from scratch β you resume from the last passing checkpoint with guaranteed clean state. The phrase to keep is out-of-band. The verification cannot come from the same agent whose work it is checking, or the checkpoint proves nothing.
#24
@joeyjjooste
https://x.com/joeyjjooste/status/2103072239763456379
Reported their first fully automatic agent loop hitting the repo: a user sees an error, PostHog catches it, a Linear ticket is created, a decision model routes it, an internal agent fixes it, a PR is opened and merged. No human interaction besides a merge click, and they are looking at enabling auto-merge. This is the shortest complete description in this feed of a production loop that starts at a real user's error and ends at shipped code, and the only human gate left is one button.
https://x.com/joeyjjooste/status/2103072239763456379
Reported their first fully automatic agent loop hitting the repo: a user sees an error, PostHog catches it, a Linear ticket is created, a decision model routes it, an internal agent fixes it, a PR is opened and merged. No human interaction besides a merge click, and they are looking at enabling auto-merge. This is the shortest complete description in this feed of a production loop that starts at a real user's error and ends at shipped code, and the only human gate left is one button.
#25
@ishaansehgal
https://x.com/ishaansehgal/status/2102912828202164713
Called the direction and then the problem with it in the same breath. The next update makes everything a managed agent β the agent loop runs in the cloud by default, with the option of a local daemon if you want a local device. He calls that inevitable and also concerning, and states the thesis plainly: you should not rent your control plane from a model provider. Pick your models, your cloud, your prices, own your data. This is the cleanest statement of the counter-position to the managed-agent wave that every major lab shipped this week.
https://x.com/ishaansehgal/status/2102912828202164713
Called the direction and then the problem with it in the same breath. The next update makes everything a managed agent β the agent loop runs in the cloud by default, with the option of a local daemon if you want a local device. He calls that inevitable and also concerning, and states the thesis plainly: you should not rent your control plane from a model provider. Pick your models, your cloud, your prices, own your data. This is the cleanest statement of the counter-position to the managed-agent wave that every major lab shipped this week.
#26
@paddix
https://x.com/paddix/status/2102438430013628677
Announced Managed Agents in public preview with the framing that agents are not traditional applications running inside a VM β they are stateful, event-driven loops that reason in tokens, execute in bursts, call external systems and preserve state across sessions. The pre-wired pieces are the interesting list: a dedicated secure microVM sandbox per session, durable execution with pause, resume, checkpoint and fork, integrated routing across hosted open-weight and frontier models, one managed MCP endpoint for 16,000-plus tools, execution-time credential brokering so the agent never sees the key, and unified telemetry across runtime, model and tool calls. His claim is that the unit of cloud computing is becoming the agent run rather than the provisioned VM.
https://x.com/paddix/status/2102438430013628677
Announced Managed Agents in public preview with the framing that agents are not traditional applications running inside a VM β they are stateful, event-driven loops that reason in tokens, execute in bursts, call external systems and preserve state across sessions. The pre-wired pieces are the interesting list: a dedicated secure microVM sandbox per session, durable execution with pause, resume, checkpoint and fork, integrated routing across hosted open-weight and frontier models, one managed MCP endpoint for 16,000-plus tools, execution-time credential brokering so the agent never sees the key, and unified telemetry across runtime, model and tool calls. His claim is that the unit of cloud computing is becoming the agent run rather than the provisioned VM.
#27
@YokushObiwan
https://x.com/YokushObiwan/status/2102871969586909644
Made the sharpest observation about micropayments inside an agent loop: it moves the spend decision from a procurement form to a runtime call. A subscription has a human gate β somebody signs an annual order, and that gate is the control. Per-request micropayments remove it, so the agent buys data thousands of times a day and the only thing between it and the budget is a ceiling set once and never revisited. His conclusion is the one the whole agentic-commerce push is not answering: the limit is the product, not the rail. Who sets the ceiling, what happens the first time the agent decides a $5,000 pull is worth it, and whether anyone can reconstruct afterwards why it thought so.
https://x.com/YokushObiwan/status/2102871969586909644
Made the sharpest observation about micropayments inside an agent loop: it moves the spend decision from a procurement form to a runtime call. A subscription has a human gate β somebody signs an annual order, and that gate is the control. Per-request micropayments remove it, so the agent buys data thousands of times a day and the only thing between it and the budget is a ceiling set once and never revisited. His conclusion is the one the whole agentic-commerce push is not answering: the limit is the product, not the rail. Who sets the ceiling, what happens the first time the agent decides a $5,000 pull is worth it, and whether anyone can reconstruct afterwards why it thought so.
#28
@ayyazdev
https://x.com/ayyazdev/status/2102822946729259335
Wrote up Cloudflare's Worker Previews, where each Git branch gets its own production-like Worker with a separate URL, config, observability and an isolated Durable Object and Container namespace. The suggested agent loop is the transferable bit: deploy the preview, open it with Playwright MCP, query Workers Observability MCP for traces, patch, redeploy. Bad migrations stay on that branch instead of hitting shared staging. Multi-Worker request paths and Queue consumers inside previews are still coming, but he notes the Durable Object isolation alone is already useful.
https://x.com/ayyazdev/status/2102822946729259335
Wrote up Cloudflare's Worker Previews, where each Git branch gets its own production-like Worker with a separate URL, config, observability and an isolated Durable Object and Container namespace. The suggested agent loop is the transferable bit: deploy the preview, open it with Playwright MCP, query Workers Observability MCP for traces, patch, redeploy. Bad migrations stay on that branch instead of hitting shared staging. Multi-Worker request paths and Queue consumers inside previews are still coming, but he notes the Durable Object isolation alone is already useful.
#29
@ayyazdev
https://x.com/ayyazdev/status/2102912659343749180
Relayed how GitLab cut code per agentic flow by 45%. Early flows were roughly 450-plus lines of ad-hoc LangGraph Python each, and four flows in the graphs were a mess of one-off nodes, custom state and tests nobody wanted to touch. Flow Registry is the fix: you declare agents, human-in-the-loop checkpoints and fixed steps in YAML, routers branch on shared context, and the platform owns the agent loop once so builders stop reimplementing it. Their Fix Pipeline flow shows why structure beats stuffing everything into one prompt β a judge agent picks retry versus plan versus code change, then routers send traffic down the right path, and cheaper models can sit on the high-frequency branches because the process lives in the config.
https://x.com/ayyazdev/status/2102912659343749180
Relayed how GitLab cut code per agentic flow by 45%. Early flows were roughly 450-plus lines of ad-hoc LangGraph Python each, and four flows in the graphs were a mess of one-off nodes, custom state and tests nobody wanted to touch. Flow Registry is the fix: you declare agents, human-in-the-loop checkpoints and fixed steps in YAML, routers branch on shared context, and the platform owns the agent loop once so builders stop reimplementing it. Their Fix Pipeline flow shows why structure beats stuffing everything into one prompt β a judge agent picks retry versus plan versus code change, then routers send traffic down the right path, and cheaper models can sit on the high-frequency branches because the process lives in the config.
#30
@ayyazdev
https://x.com/ayyazdev/status/2103000787768984050
Covered Google open-sourcing AX under Apache 2.0, a Kubernetes-style runtime for long-running agents. His framing of why agents are a weird workload is the part to keep: they spike during tool use then sit idle waiting on the model or a human, so warm sandboxes burn money in that idle window while cold starts wreck the interactive loop. AX runs each session as a stateful actor, checkpoints and suspends when idle, and resumes in under a second. Four CRDs: Task, Workspace, Gateway, Model. He would reach for Gateway first β explicit host and port allowlists plus credential injection on outbound calls, which is exactly the containment most DIY agent sandboxes skip.
https://x.com/ayyazdev/status/2103000787768984050
Covered Google open-sourcing AX under Apache 2.0, a Kubernetes-style runtime for long-running agents. His framing of why agents are a weird workload is the part to keep: they spike during tool use then sit idle waiting on the model or a human, so warm sandboxes burn money in that idle window while cold starts wreck the interactive loop. AX runs each session as a stateful actor, checkpoints and suspends when idle, and resumes in under a second. Four CRDs: Task, Workspace, Gateway, Model. He would reach for Gateway first β explicit host and port allowlists plus credential injection on outbound calls, which is exactly the containment most DIY agent sandboxes skip.
#31
@adamm285
https://x.com/adamm285/status/2102260919526928405
Named three anti-patterns that make agent loops expensive, and the framing is right: token efficiency is not an LLM problem, it is a systems architecture problem. Naive agents have a grep reflex, burning 2,000-plus tokens on boot frantically reading files. Dynamic prefixes bust the KV cache every turn. And using frontier inference to fix indentation is an anti-pattern when deterministic formatters exist. His own formalization treats the codebase as a furnished office with AST boundaries, token-budgeted blackboards capped at 350 tokens, and deterministic pre-flight gates that fail on disk before burning any model tokens.
https://x.com/adamm285/status/2102260919526928405
Named three anti-patterns that make agent loops expensive, and the framing is right: token efficiency is not an LLM problem, it is a systems architecture problem. Naive agents have a grep reflex, burning 2,000-plus tokens on boot frantically reading files. Dynamic prefixes bust the KV cache every turn. And using frontier inference to fix indentation is an anti-pattern when deterministic formatters exist. His own formalization treats the codebase as a furnished office with AST boundaries, token-budgeted blackboards capped at 350 tokens, and deterministic pre-flight gates that fail on disk before burning any model tokens.
#32
@farmer_pink
https://x.com/farmer_pink/status/2102776733208563947
Noticed that the major labs are converging on the same problem from different directions β GPT-6 with a million-token context plus serious work on prompt caching for persistent agents, DeepSeek V4 with a million-token context plus token-wise compression and sparse attention, MiMo with cross-layer KV sharing plus sparse retrieval and early-exit prefill β and drew the right conclusion. How long is your context window is becoming a last-generation question. The next one is: by round 30 of an agent loop, how many times did you pay to process that context?
https://x.com/farmer_pink/status/2102776733208563947
Noticed that the major labs are converging on the same problem from different directions β GPT-6 with a million-token context plus serious work on prompt caching for persistent agents, DeepSeek V4 with a million-token context plus token-wise compression and sparse attention, MiMo with cross-layer KV sharing plus sparse retrieval and early-exit prefill β and drew the right conclusion. How long is your context window is becoming a last-generation question. The next one is: by round 30 of an agent loop, how many times did you pay to process that context?
#33
@JoshARosen
https://x.com/JoshARosen/status/2102772898788249865
Predicted a new AI primitive somewhere between a model call and an agent loop that makes LLMs much more accountable. Think invoke or responses.create, but paired with a fast decision model: you pass in the prompt and messages, typed questions, thresholds for those answers, and max iterations, and the reasoning model loops until the decision model says the answers meet the thresholds. Basically the smallest possible agent loop packaged into a single invocation. If it lands, it moves termination conditions out of prompt engineering and into an API signature, which is where OnFinality's complaint above says they belong.
https://x.com/JoshARosen/status/2102772898788249865
Predicted a new AI primitive somewhere between a model call and an agent loop that makes LLMs much more accountable. Think invoke or responses.create, but paired with a fast decision model: you pass in the prompt and messages, typed questions, thresholds for those answers, and max iterations, and the reasoning model loops until the decision model says the answers meet the thresholds. Basically the smallest possible agent loop packaged into a single invocation. If it lands, it moves termination conditions out of prompt engineering and into an API signature, which is where OnFinality's complaint above says they belong.
#34
@twid
https://x.com/twid/status/2102328541576581567
Pushed back usefully on the enthusiasm about caching making agent loops cheap. Many normal workflows do not have high hit rates: 30K tokens is a lot of text but not a lot for images or video, so anyone feeding screenshots, images or video clips burns through the cache fast. RAG against a lot of documents will be slow, as will analyzing a large single PDF. And multiuser with two or more sessions will thrash the SSD KV cache, so shared use cases need to be scoped properly. He agrees that a long-running single agent loop will be speedy β the caveat is everything that is not that shape.
https://x.com/twid/status/2102328541576581567
Pushed back usefully on the enthusiasm about caching making agent loops cheap. Many normal workflows do not have high hit rates: 30K tokens is a lot of text but not a lot for images or video, so anyone feeding screenshots, images or video clips burns through the cache fast. RAG against a lot of documents will be slow, as will analyzing a large single PDF. And multiuser with two or more sessions will thrash the SSD KV cache, so shared use cases need to be scoped properly. He agrees that a long-running single agent loop will be speedy β the caveat is everything that is not that shape.
#35
@DivyanshT91162
https://x.com/DivyanshT91162/status/2102276746842415534
Summarised VideoGen-Agent, which turns video generation into an agentic loop rather than one blind prompt: prompt, reason, search or simulate, generate, verify, refine. The agent can use web search for procedural knowledge, image search for identity and visual references, physics simulation for realistic motion, object detection for verification, depth estimation for scene consistency and multiple generation tools for different tasks. One shared agent was trained across six hard categories. Base video generator scored 56.5, VideoGen-Agent 75.6, and with upgraded generation tools 86.1, with no additional agent training. Human raters preferred the upgraded configuration over the strongest standalone baseline in 84.3% of comparisons. The bigger idea is that the AI learns when it should not generate from memory and should use a tool first.
https://x.com/DivyanshT91162/status/2102276746842415534
Summarised VideoGen-Agent, which turns video generation into an agentic loop rather than one blind prompt: prompt, reason, search or simulate, generate, verify, refine. The agent can use web search for procedural knowledge, image search for identity and visual references, physics simulation for realistic motion, object detection for verification, depth estimation for scene consistency and multiple generation tools for different tasks. One shared agent was trained across six hard categories. Base video generator scored 56.5, VideoGen-Agent 75.6, and with upgraded generation tools 86.1, with no additional agent training. Human raters preferred the upgraded configuration over the strongest standalone baseline in 84.3% of comparisons. The bigger idea is that the AI learns when it should not generate from memory and should use a tool first.
#36
@thehypedotnews
https://x.com/thehypedotnews/status/2102527541051633903
Ran the same roughly 100k-token prompt through three models to build three post-apocalyptic films as single HTML files, and the methodology matters: GPT-6 Astra got one prompt and one reply with no agent loop, while Opus 5.5 and Fable 5.1 ran as agents in Claude Code β write the file, open it in a browser, look at the frames, fix, repeat. Two findings stand out. Opus 5.5 found its own bugs by looking at its own frames, including a NaN in the light shafts drawing black dashed lines in the diner and patch used as a variable name, which is reserved in GLSL. And the loop gets cheaper as it goes: the first film took 46 model calls and $9.94, then 16 calls for $4.85 and 17 for $4.59, reusing its own kit. Of the $19.38 Opus total, $8.80 is cache reads, because every agent step re-reads a 200k to 450k context.
https://x.com/thehypedotnews/status/2102527541051633903
Ran the same roughly 100k-token prompt through three models to build three post-apocalyptic films as single HTML files, and the methodology matters: GPT-6 Astra got one prompt and one reply with no agent loop, while Opus 5.5 and Fable 5.1 ran as agents in Claude Code β write the file, open it in a browser, look at the frames, fix, repeat. Two findings stand out. Opus 5.5 found its own bugs by looking at its own frames, including a NaN in the light shafts drawing black dashed lines in the diner and patch used as a variable name, which is reserved in GLSL. And the loop gets cheaper as it goes: the first film took 46 model calls and $9.94, then 16 calls for $4.85 and 17 for $4.59, reusing its own kit. Of the $19.38 Opus total, $8.80 is cache reads, because every agent step re-reads a 200k to 450k context.
#37
@jjohana
https://x.com/jjohana/status/2103003083118715067
Worked out why GPT-6 Sol sometimes regresses on professional-work benchmarks despite beating its predecessor overall, and the answer is the harness. AA-Briefcase and GDPval run Sol inside Stirrup, not Work; Terminal-Bench uses mini-swe-agent, not Codex. In OpenAI's native Codex harness the scores are 57 versus 55 with Terminal-Bench jumping from 37% to 43%. He also notes the laziness people report at lower reasoning levels β shorter answers, earlier stopping, fewer iterations β is partly harness-dependent, because in the native harness OpenAI controls the agent loop, context management, tools, iteration and stopping criteria. His conclusion should be pinned somewhere: benchmarks increasingly measure model times harness, not just the model.
https://x.com/jjohana/status/2103003083118715067
Worked out why GPT-6 Sol sometimes regresses on professional-work benchmarks despite beating its predecessor overall, and the answer is the harness. AA-Briefcase and GDPval run Sol inside Stirrup, not Work; Terminal-Bench uses mini-swe-agent, not Codex. In OpenAI's native Codex harness the scores are 57 versus 55 with Terminal-Bench jumping from 37% to 43%. He also notes the laziness people report at lower reasoning levels β shorter answers, earlier stopping, fewer iterations β is partly harness-dependent, because in the native harness OpenAI controls the agent loop, context management, tools, iteration and stopping criteria. His conclusion should be pinned somewhere: benchmarks increasingly measure model times harness, not just the model.
#38
@Nitikshofficial
https://x.com/Nitikshofficial/status/2102564638952997172
Described what actually happens on model-launch day, which matches what a lot of people were about to blame on the new weights. People blame the new model for token spikes and CLAUDE.md drift, then find an old effort default, a stale tools permission or a leftover thinking setting that no longer means what it did. His prescription is a short preflight before you point production at a new release: dump current defaults, re-read the migration notes, and re-run one known agent loop with tracing on. He calls the boring settings audit the highest-ROI post of a launch week, and after this window's default-effort change he is right.
https://x.com/Nitikshofficial/status/2102564638952997172
Described what actually happens on model-launch day, which matches what a lot of people were about to blame on the new weights. People blame the new model for token spikes and CLAUDE.md drift, then find an old effort default, a stale tools permission or a leftover thinking setting that no longer means what it did. His prescription is a short preflight before you point production at a new release: dump current defaults, re-read the migration notes, and re-run one known agent loop with tracing on. He calls the boring settings audit the highest-ROI post of a launch week, and after this window's default-effort change he is right.
#39
@lzyzddhg
https://x.com/lzyzddhg/status/2102412194801709067
Cut through the agent-loop discourse in two sentences: the bottleneck is not the agent loop, it is the supervision loop. Pilots die on verification, because nobody can answer what did it change and is that correct at 3am. The ones that survive ship an audit trail first and autonomy second. That ordering β audit trail before autonomy β is the single most repeated structural claim across this window, and it shows up independently in the security interview, the sandbox architecture argument and the managed-agent announcements.
https://x.com/lzyzddhg/status/2102412194801709067
Cut through the agent-loop discourse in two sentences: the bottleneck is not the agent loop, it is the supervision loop. Pilots die on verification, because nobody can answer what did it change and is that correct at 3am. The ones that survive ship an audit trail first and autonomy second. That ordering β audit trail before autonomy β is the single most repeated structural claim across this window, and it shows up independently in the security interview, the sandbox architecture argument and the managed-agent announcements.
#40
@Its_clade
https://x.com/Its_clade/status/2102757691890245639
Published the smallest useful trading desk in this feed: a three-agent loop with a fixed prompt each. The macro decoder takes FOMC minutes, Fed speeches and CME FedWatch probabilities and scores hawkish or dovish 1 to 10, lists three second-order effects for BTC, ETH, gold and USD, and flags what is already priced versus what is still a surprise, output as a six-line table only β with the scores kept in a running sheet so he can see when the AI's tone flips against price. The opportunity filter then asks which two pairs are most mispriced relative to that macro score, with invalidation levels. The strategy builder feeds survivors plus 90 days of 4h candles into a backtest, with rules he never skips: max 1 to 2% risk per idea, a clear invalidation, and no trade if funding is already extreme in the same direction. His framing is the point: most people ask what BTC will do, he asks what is already priced, what is the surprise, and where is my invalidation.
https://x.com/Its_clade/status/2102757691890245639
Published the smallest useful trading desk in this feed: a three-agent loop with a fixed prompt each. The macro decoder takes FOMC minutes, Fed speeches and CME FedWatch probabilities and scores hawkish or dovish 1 to 10, lists three second-order effects for BTC, ETH, gold and USD, and flags what is already priced versus what is still a surprise, output as a six-line table only β with the scores kept in a running sheet so he can see when the AI's tone flips against price. The opportunity filter then asks which two pairs are most mispriced relative to that macro score, with invalidation levels. The strategy builder feeds survivors plus 90 days of 4h candles into a backtest, with rules he never skips: max 1 to 2% risk per idea, a clear invalidation, and no trade if funding is already extreme in the same direction. His framing is the point: most people ask what BTC will do, he asks what is already priced, what is the surprise, and where is my invalidation.
#41
@HarryTandy
https://x.com/HarryTandy/status/2102450981665493392
Flagged a 64-page paper from 35 AI researchers on graph engineering, described as a map for turning one messy agent loop into explicit tasks, specialist teams, checkpoints, recovery paths and verification. His suggested use is the practical bit and matches the direction of everything else here: drop the PDF into Claude Code or Codex and ask it to turn your longest workflow into a graph you can pause, inspect and resume.
https://x.com/HarryTandy/status/2102450981665493392
Flagged a 64-page paper from 35 AI researchers on graph engineering, described as a map for turning one messy agent loop into explicit tasks, specialist teams, checkpoints, recovery paths and verification. His suggested use is the practical bit and matches the direction of everything else here: drop the PDF into Claude Code or Codex and ask it to turn your longest workflow into a graph you can pause, inspect and resume.
#42
@anniewangtech
https://x.com/anniewangtech/status/2103157966577033412
Enumerated five directions for a harness's recursive self-improvement, which is the cleanest taxonomy anyone posted this window: the agent loop covering step-by-step logic and error recovery; tool use covering API selection and parameter formatting; observation management covering filtering environmental noise; context management covering optimization of long-horizon tokens; and task completion detection, which she glosses simply as knowing when the job is done. That last one is the same gap OnFinality flagged from the builder side.
https://x.com/anniewangtech/status/2103157966577033412
Enumerated five directions for a harness's recursive self-improvement, which is the cleanest taxonomy anyone posted this window: the agent loop covering step-by-step logic and error recovery; tool use covering API selection and parameter formatting; observation management covering filtering environmental noise; context management covering optimization of long-horizon tokens; and task completion detection, which she glosses simply as knowing when the job is done. That last one is the same gap OnFinality flagged from the builder side.
#43
@LatBenela
https://x.com/LatBenela/status/2102293991681363969
Wrote the long-form argument for starting with harness self-improvement rather than model self-improvement, and it is the best-structured piece of thinking in the batch even if you discount the project it is attached to. Give the same model to two systems and results can look unrelated; the operating system around the model is the harness. Research published in July 2026 showed a few iterations of harness self-improvement lifting low-reasoning-effort agents past matching max-reasoning setups across 30 synthetic ML research tasks in finance, robotics and pharmacy, while cutting inference cost by as much as 60% β with most of the gain from better context management and cleaner information flow between agents, not longer chains of thought. His follow-on question is the one the field keeps dodging: once an agent can change how it works, what tells it the change actually helped? He cites a survey of 1,250 self-improvement papers treating self-evaluation as its own category precisely because weak evaluators produce self-confirming loops and collapse.
https://x.com/LatBenela/status/2102293991681363969
Wrote the long-form argument for starting with harness self-improvement rather than model self-improvement, and it is the best-structured piece of thinking in the batch even if you discount the project it is attached to. Give the same model to two systems and results can look unrelated; the operating system around the model is the harness. Research published in July 2026 showed a few iterations of harness self-improvement lifting low-reasoning-effort agents past matching max-reasoning setups across 30 synthetic ML research tasks in finance, robotics and pharmacy, while cutting inference cost by as much as 60% β with most of the gain from better context management and cleaner information flow between agents, not longer chains of thought. His follow-on question is the one the field keeps dodging: once an agent can change how it works, what tells it the change actually helped? He cites a survey of 1,250 self-improvement papers treating self-evaluation as its own category precisely because weak evaluators produce self-confirming loops and collapse.
#44
@gigalester
https://x.com/gigalester/status/2102380440732516423
Made the most precise diagnosis of why the decision-model split is not just function calling with extra steps. Every agent loop today makes the same mistake: it asks the same model to write the plan and to decide which branch to take. One job needs slow deliberate reasoning; the other needs a fast calibrated yes or no under load, thousands of times a second. His fine print is refreshingly honest β the benchmarks are the vendor's own, it only works when the possible answers are known upfront, so it is a router and gatekeeper rather than a reasoner, and coupling your approval logic to a proprietary decision model is a new kind of vendor lock-in, just a quieter one. His closing line lands: the LLM was never the slow part because it was dumb, it was slow because you were asking it to decide when you only needed it to guess.
https://x.com/gigalester/status/2102380440732516423
Made the most precise diagnosis of why the decision-model split is not just function calling with extra steps. Every agent loop today makes the same mistake: it asks the same model to write the plan and to decide which branch to take. One job needs slow deliberate reasoning; the other needs a fast calibrated yes or no under load, thousands of times a second. His fine print is refreshingly honest β the benchmarks are the vendor's own, it only works when the possible answers are known upfront, so it is a router and gatekeeper rather than a reasoner, and coupling your approval logic to a proprietary decision model is a new kind of vendor lock-in, just a quieter one. His closing line lands: the LLM was never the slow part because it was dumb, it was slow because you were asking it to decide when you only needed it to guess.
#45
@DieHeartMansoor
https://x.com/DieHeartMansoor/status/2102334392198984184
Answered a question about search inside an agentic loop with the honest version: there are options, none clean. SerpAPI or ValueSERP MCPs give live SERP data, Brave Search MCP has a free tier, and the Google Search Console API is official but runs two to three days behind. There is no native Google Search CLI, and he says the gap is real β especially for real-time rank tracking inside an agentic loop. Small, but it is a named, specific infrastructure hole rather than a vibe.
https://x.com/DieHeartMansoor/status/2102334392198984184
Answered a question about search inside an agentic loop with the honest version: there are options, none clean. SerpAPI or ValueSERP MCPs give live SERP data, Brave Search MCP has a free tier, and the Google Search Console API is official but runs two to three days behind. There is no native Google Search CLI, and he says the gap is real β especially for real-time rank tracking inside an agentic loop. Small, but it is a named, specific infrastructure hole rather than a vibe.
#46
@premsaivarma_ch
https://x.com/premsaivarma_ch/status/2102989851192913973
Two lines, and they are the right two: token spend upticks mean nothing without an eval on accepted diffs, and he would kill any coding-agent loop that cannot beat human merge quality on a frozen week. Freezing the week is the part most people skip β without a fixed comparison period, every claimed improvement is measured against whatever the team happened to be working on.
https://x.com/premsaivarma_ch/status/2102989851192913973
Two lines, and they are the right two: token spend upticks mean nothing without an eval on accepted diffs, and he would kill any coding-agent loop that cannot beat human merge quality on a frozen week. Freezing the week is the part most people skip β without a fixed comparison period, every claimed improvement is measured against whatever the team happened to be working on.
#47
@FlexbuildWill
https://x.com/FlexbuildWill/status/2102533106934644828
Gave the only piece of timing advice on governance anyone posted: gate agent write access the same week you ship the first agent loop. Prod secrets stay off the agent host, every privileged tool needs a named human approval path, and you log denied actions daily. His closing line is the one to quote at anyone planning to add controls later β governance after the agent can already ship to prod is just incident response with extra slides.
https://x.com/FlexbuildWill/status/2102533106934644828
Gave the only piece of timing advice on governance anyone posted: gate agent write access the same week you ship the first agent loop. Prod secrets stay off the agent host, every privileged tool needs a named human approval path, and you log denied actions daily. His closing line is the one to quote at anyone planning to add controls later β governance after the agent can already ship to prod is just incident response with extra slides.
#48
@BugoTheCat
https://x.com/BugoTheCat/status/2103051589862801566
Pushed back on the one-shot demos, and the pushback is grounded: he doubts these one-shot stories are without lies, because if he prompts something now it will not give him the complete thing, and most people doing regular jobs need multiple prompts just to solve some problems. His caveat is the honest part β it works only with some automatic agent loop with harnesses and whatever, which is precisely the gap between the demo videos and the working day.
https://x.com/BugoTheCat/status/2103051589862801566
Pushed back on the one-shot demos, and the pushback is grounded: he doubts these one-shot stories are without lies, because if he prompts something now it will not give him the complete thing, and most people doing regular jobs need multiple prompts just to solve some problems. His caveat is the honest part β it works only with some automatic agent loop with harnesses and whatever, which is precisely the gap between the demo videos and the working day.
π‘ Eco Products Radar
Eco Products Radar
Jev / TypeSafe decision models β the recurring answer to who decides inside the loop, appearing in self-improving agents, routing, verification and podcast segmentation
SoL-Pi β NVIDIA, NTU and MIT's self-improving harness, 152 proposed changes and four survivors, cited independently by three accounts
OpenRSI-Index β the new open benchmark for recursive self-improvement, with full agent trajectories published
Claude Code β used as the agent under test in the OpenRSI optimizer discovery and as the agent loop in the three-film render comparison
Codex / GPT-6 β the other agent under test, and the subject of the model-times-harness benchmarking argument
MCP β the connective layer in every loop described here, from Playwright and Observability to Search and Home
Managed agent runtimes β DigitalOcean Managed Agents, Google AX, Cloudflare Worker Previews and GitLab Flow Registry all shipped the same week
Autoresearch as a GPU platform β the sfcompute rename, now used to create nodes, run containers and tear them down inside the coding workflow
Jev / TypeSafe decision models β the recurring answer to who decides inside the loop, appearing in self-improving agents, routing, verification and podcast segmentation
SoL-Pi β NVIDIA, NTU and MIT's self-improving harness, 152 proposed changes and four survivors, cited independently by three accounts
OpenRSI-Index β the new open benchmark for recursive self-improvement, with full agent trajectories published
Claude Code β used as the agent under test in the OpenRSI optimizer discovery and as the agent loop in the three-film render comparison
Codex / GPT-6 β the other agent under test, and the subject of the model-times-harness benchmarking argument
MCP β the connective layer in every loop described here, from Playwright and Observability to Search and Home
Managed agent runtimes β DigitalOcean Managed Agents, Google AX, Cloudflare Worker Previews and GitLab Flow Registry all shipped the same week
Autoresearch as a GPU platform β the sfcompute rename, now used to create nodes, run containers and tear them down inside the coding workflow
Comments