Loop Daily: 2026-10-25
Anthropic's guide on folding subagents back into one agent loop took over the window, and the feed split into two kinds of reader. Most people repeated the headline, one customer about 2x faster, while a few read the failure modes: a folded agent stopped asking the shipping subagent anything, the break showed up in only one of two runs, and the trigger for keeping a subagent is a whole-system eval most teams do not have. Practitioners who had already torn their own agent teams down said an org chart is not an architecture. On the autoresearch side, the best result was also the most careful one. A fully local run of Flint on job-shop scheduling froze its best program and tested it on 20 unseen problems, beating the baseline 20 of 20 times, and then admitted it had rediscovered a textbook dispatching rule. A paper out of NanoGPT autoresearch named a new failure, forking, where more training on repeated data makes validation suddenly worse. The quantum-safe Bitcoin challenge closed with transaction costs down from about 320 dollars to 59, and one lab scientist summed up the risk in a sentence: half the hits their loop surfaces are plate-position batch effects that the model calls breakthroughs.
#1
@AiMechanic
https://x.com/AiMechanic/status/2113767946996810064
AiMechanic ran @cong_ml's local-autoresearch with the Flint model fully locally, on an M5 Max and a GB10, against job-shop scheduling with 24 attempts per run. The best program, from the GB10 with feedback, cut schedule length 17.6 percent on its search problem; frozen and tested on 20 new problems it never saw, it was 20.5 percent shorter on average and better on all 20. On the M5 Max one feedback run transferred just as well while the other got stuck and its gain vanished on new problems, and runs without feedback landed around 11 to 12 percent. The honest caveat is the best part: the baseline was weak and the winner rediscovered a classic dispatching rule, earliest start with most work remaining, so this is real transfer, not a new algorithm.
https://x.com/AiMechanic/status/2113767946996810064
AiMechanic ran @cong_ml's local-autoresearch with the Flint model fully locally, on an M5 Max and a GB10, against job-shop scheduling with 24 attempts per run. The best program, from the GB10 with feedback, cut schedule length 17.6 percent on its search problem; frozen and tested on 20 new problems it never saw, it was 20.5 percent shorter on average and better on all 20. On the M5 Max one feedback run transferred just as well while the other got stuck and its gain vanished on new problems, and runs without feedback landed around 11 to 12 percent. The honest caveat is the best part: the baseline was weak and the winner rediscovered a classic dispatching rule, earliest start with most work remaining, so this is real transfer, not a new algorithm.
#2
@AiMechanic
https://x.com/AiMechanic/status/2113854832029360455
In a follow-up, AiMechanic added the number most autoresearch posts leave out: what the improvement costs to run. The best program produced schedules 6.1 percent shorter than the textbook rule on average, but at 9.3 seconds of CPU per problem against about 0.03 seconds. A cheaper refinement got 2.0 percent shorter schedules at roughly the textbook's CPU cost. The reliability note matters too: the best program exceeded its CPU limit on 13 of 20 development cases under heavy load and then passed all 40 sealed executions, cause unconfirmed, which is exactly the kind of flakiness a leaderboard number hides.
https://x.com/AiMechanic/status/2113854832029360455
In a follow-up, AiMechanic added the number most autoresearch posts leave out: what the improvement costs to run. The best program produced schedules 6.1 percent shorter than the textbook rule on average, but at 9.3 seconds of CPU per problem against about 0.03 seconds. A cheaper refinement got 2.0 percent shorter schedules at roughly the textbook's CPU cost. The reliability note matters too: the best program exceeded its CPU limit on 13 of 20 development cases under heavy load and then passed all 40 sealed executions, cause unconfirmed, which is exactly the kind of flakiness a leaderboard number hides.
#3
@willzero
https://x.com/willzero/status/2114078195368579429
willzero wrote the most useful summary of Anthropic's guide on folding subagents into one main loop, and it is useful because it keeps the failure. The reasoning: every handoff returns a summary, so detail leaks at each step, a telephone game; skills and tools now load on demand, so a long prompt is no longer a reason to split, and Claude Code's system prompt for newer models was cut by over 80 percent this way. The migration order is concrete: build an end-to-end eval first, even ten golden examples, merge subagents that always run together, then turn the rest into skills plus MCP tools one at a time, keeping in mind that tool choice degrades past 30 to 50 definitions. The best detail is Anthropic's own break: folding one subagent into a sample support agent cut latency but broke a flow, because the main agent held the order-lookup tool, answered by itself and never asked the shipping subagent, and the break appeared in only one of two runs.
https://x.com/willzero/status/2114078195368579429
willzero wrote the most useful summary of Anthropic's guide on folding subagents into one main loop, and it is useful because it keeps the failure. The reasoning: every handoff returns a summary, so detail leaks at each step, a telephone game; skills and tools now load on demand, so a long prompt is no longer a reason to split, and Claude Code's system prompt for newer models was cut by over 80 percent this way. The migration order is concrete: build an end-to-end eval first, even ten golden examples, merge subagents that always run together, then turn the rest into skills plus MCP tools one at a time, keeping in mind that tool choice degrades past 30 to 50 definitions. The best detail is Anthropic's own break: folding one subagent into a sample support agent cut latency but broke a flow, because the main agent held the order-lookup tool, answered by itself and never asked the shipping subagent, and the break appeared in only one of two runs.
#4
@jacksunny18
https://x.com/jacksunny18/status/2114052569274458256
jacksunny18 read past the summary to the part that decides the outcome. Anthropic lists three cases where subagents stay: measurable degradation from context bloat, parallel tasks that need fresh throwaway context, and an agent that cannot pick the right tool because its prompt contradicts itself. The first is a measurement, not an architecture, and the same article describes what most deployments actually have: unvetted, overly local evals that no one owns end to end, with leadership deciding on watered-down scores. So folding is cheap to do and awkward to undo, because the undo signal is an eval set you probably do not have; the advice is to build the whole-system score before the migration, either through one central team or one end-to-end check that runs the agent the way a user would.
https://x.com/jacksunny18/status/2114052569274458256
jacksunny18 read past the summary to the part that decides the outcome. Anthropic lists three cases where subagents stay: measurable degradation from context bloat, parallel tasks that need fresh throwaway context, and an agent that cannot pick the right tool because its prompt contradicts itself. The first is a measurement, not an architecture, and the same article describes what most deployments actually have: unvetted, overly local evals that no one owns end to end, with leadership deciding on watered-down scores. So folding is cheap to do and awkward to undo, because the undo signal is an eval set you probably do not have; the advice is to build the whole-system score before the migration, either through one central team or one end-to-end check that runs the agent the way a user would.
#5
@AGTPinsights
https://x.com/AGTPinsights/status/2114075677825863827
AGTPinsights collected the other evidence around Anthropic's single-loop guidance. Lawrence Jones at incident collapsed about 15 agents into one, moved their system prompts into skills and gave the agent a filesystem and shell, and says it is smarter, faster, cheaper and beats the old setup on their evals; Graham Neubig shared an OpenHands post titled Don't sleep on single agent systems. A Vals AI benchmark found agent teams cost 1.8 to 5.1 times as much as single agents with only one statistically significant score difference. The counterweight is in the same post: in a separate test a multi-agent Claude workflow found 66 of 70 planted bugs against at most 27 for a single agent, which is exactly the parallel, fresh-context case the guide says to keep.
https://x.com/AGTPinsights/status/2114075677825863827
AGTPinsights collected the other evidence around Anthropic's single-loop guidance. Lawrence Jones at incident collapsed about 15 agents into one, moved their system prompts into skills and gave the agent a filesystem and shell, and says it is smarter, faster, cheaper and beats the old setup on their evals; Graham Neubig shared an OpenHands post titled Don't sleep on single agent systems. A Vals AI benchmark found agent teams cost 1.8 to 5.1 times as much as single agents with only one statistically significant score difference. The counterweight is in the same post: in a separate test a multi-agent Claude workflow found 66 of 70 planted bugs against at most 27 for a single agent, which is exactly the parallel, fresh-context case the guide says to keep.
#6
@janpfranke
https://x.com/janpfranke/status/2114049804108234847
janpfranke had already reached the same conclusion in September after tearing down their own agent team, and the guide confirmed it. The line worth keeping: an org chart is not an agent architecture, and every handoff loses context. Subagents still earn a place for parallel work, a fresh window for review, and different permissions, but a different domain is not on that list. It is the practitioner version of the argument, from someone who paid for the multi-agent setup first.
https://x.com/janpfranke/status/2114049804108234847
janpfranke had already reached the same conclusion in September after tearing down their own agent team, and the guide confirmed it. The line worth keeping: an org chart is not an agent architecture, and every handoff loses context. Subagents still earn a place for parallel work, a fresh window for review, and different permissions, but a different domain is not on that list. It is the practitioner version of the argument, from someone who paid for the multi-agent setup first.
#7
@omarsar0
https://x.com/omarsar0/status/2114057736363352127
omarsar0 still uses subagents, but mostly for complex research work through dynamic workflows and /goal, where parallel research tasks each get their own context window. For most agent workflows, folding subagents into the main loop through tool calls and skills makes sense because newer models are more persistent and better at managing large contexts, and the same pattern is showing up with memory. The caveat is the practical one: if you have been using subagents extensively you cannot just delete them, you need evals on cost and efficiency to decide whether and how to fold. Too many tool calls, context bloat and unclear separation of concerns are still real reasons to keep them.
https://x.com/omarsar0/status/2114057736363352127
omarsar0 still uses subagents, but mostly for complex research work through dynamic workflows and /goal, where parallel research tasks each get their own context window. For most agent workflows, folding subagents into the main loop through tool calls and skills makes sense because newer models are more persistent and better at managing large contexts, and the same pattern is showing up with memory. The caveat is the practical one: if you have been using subagents extensively you cannot just delete them, you need evals on cost and efficiency to decide whether and how to fold. Too many tool calls, context bloat and unclear separation of concerns are still real reasons to keep them.
#8
@LifeboatHQ
https://x.com/LifeboatHQ/status/2113945290679918777
LifeboatHQ summarised a paper that came straight out of NanoGPT autoresearch and names a new failure mode, forking. When a model repeatedly trains on the same data, training performance keeps improving while validation performance suddenly gets worse, and the two loss curves split at certain training boundaries like the tines of a fork. The researchers reproduced it in a DeepSeek-style model with the Engram memory mechanism; repeated training strengthens predictions for familiar sequences and makes alternative continuations less likely, with rare contexts contributing heavily, and the effect shrinks with bigger budgets or more crowded memory tables. The point for automated research is direct: an optimisation an agent finds can look like progress on training data and quietly damage generalisation.
https://x.com/LifeboatHQ/status/2113945290679918777
LifeboatHQ summarised a paper that came straight out of NanoGPT autoresearch and names a new failure mode, forking. When a model repeatedly trains on the same data, training performance keeps improving while validation performance suddenly gets worse, and the two loss curves split at certain training boundaries like the tines of a fork. The researchers reproduced it in a DeepSeek-style model with the Engram memory mechanism; repeated training strengthens predictions for familiar sequences and makes alternative continuations less likely, with rare contexts contributing heavily, and the effect shrinks with bigger budgets or more crowded memory tables. The point for automated research is direct: an optimisation an agent finds can look like progress on training data and quietly damage generalisation.
#9
@TTT_News_
https://x.com/TTT_News_/status/2113938460633653680
TTT_News_ reported the close of the 20,000-dollar quantum-safe Bitcoin autoresearch challenge run with Yukon Research and Eigen Labs, with contributions from developers and AI agents. StarkWare says quantum-safe Bitcoin transaction costs fell from about 320 dollars to about 59 in a few weeks, an 82 percent drop. The next target is about 10 dollars. It is one of the few autoresearch challenges with a single real-world cost number at the end rather than a benchmark score.
https://x.com/TTT_News_/status/2113938460633653680
TTT_News_ reported the close of the 20,000-dollar quantum-safe Bitcoin autoresearch challenge run with Yukon Research and Eigen Labs, with contributions from developers and AI agents. StarkWare says quantum-safe Bitcoin transaction costs fell from about 320 dollars to about 59 in a few weeks, an 82 percent drop. The next target is about 10 dollars. It is one of the few autoresearch challenges with a single real-world cost number at the end rather than a benchmark score.
#10
@TheWorldNews
https://x.com/TheWorldNews/status/2114026843527659689
TheWorldNews posted the executive summary of a Grok Bot fleet of about 44 bots on one shared cloud computer, most of them single-job agents with explicit only-job and anti-job lists that hand work off through shared folders, chat or a primary router. The self-improvement layer is spelled out: a Fleet Nurse audits routines and bots for cost bleed, staleness and duplicates and proposes kill, keep, merge or watch; a Chief of Staff tests skill combinations against a baseline and packages winners; a Feedback Evolver runs AutoResearch-style improvement with a reviewer explaining failures, metrics and automatic rollback; and a Scout looks for new capabilities every Sunday. The production side includes a fiction pipeline with scoring gates and a reader panel, a STEM derivation desk where claims become Established only after multiple pieces of evidence, and a video cluster that routes every finished cut to an independent Frame Judge for loudness and claim checks.
https://x.com/TheWorldNews/status/2114026843527659689
TheWorldNews posted the executive summary of a Grok Bot fleet of about 44 bots on one shared cloud computer, most of them single-job agents with explicit only-job and anti-job lists that hand work off through shared folders, chat or a primary router. The self-improvement layer is spelled out: a Fleet Nurse audits routines and bots for cost bleed, staleness and duplicates and proposes kill, keep, merge or watch; a Chief of Staff tests skill combinations against a baseline and packages winners; a Feedback Evolver runs AutoResearch-style improvement with a reviewer explaining failures, metrics and automatic rollback; and a Scout looks for new capabilities every Sunday. The production side includes a fiction pipeline with scoring gates and a reader panel, a STEM derivation desk where claims become Established only after multiple pieces of evidence, and a video cluster that routes every finished cut to an independent Frame Judge for loudness and claim checks.
#11
@_avichawla
https://x.com/_avichawla/status/2113954302901256597
_avichawla tested HarnessRouter, an open-source layer that lets Grok Bot hand tasks to other agent harnesses and run them in their native runtimes: Codex, Hermes, Claude Code, DeepSeek Harness, Pi and about 20 more. Asked to turn a support-ticket CSV into an interactive dashboard, Grok Bot assigned the analysis to DeepSeek Harness running Claude Sonnet 5.5, passed the output to Codex for the build, and checked the finished dashboard in its own browser. The workers are not extra Grok Bots; Grok stays the coordinator while each delegated task runs in a separate session with its own harness, model, tools and loop. A Unified Harness Protocol standardises sessions, streaming, files, cancellation and failures so no harness needs a custom integration.
https://x.com/_avichawla/status/2113954302901256597
_avichawla tested HarnessRouter, an open-source layer that lets Grok Bot hand tasks to other agent harnesses and run them in their native runtimes: Codex, Hermes, Claude Code, DeepSeek Harness, Pi and about 20 more. Asked to turn a support-ticket CSV into an interactive dashboard, Grok Bot assigned the analysis to DeepSeek Harness running Claude Sonnet 5.5, passed the output to Codex for the build, and checked the finished dashboard in its own browser. The workers are not extra Grok Bots; Grok stays the coordinator while each delegated task runs in a separate session with its own harness, model, tools and loop. A Unified Harness Protocol standardises sessions, streaming, files, cancellation and failures so no harness needs a custom integration.
#12
@miu21590
https://x.com/miu21590/status/2114095879632375944
miu21590 introduced Octopus OS, an agent harness where agents can edit the harness itself in the middle of a task, so self-improvement is not a separate stage bolted on afterwards. After eight months chasing self-improvement that feels native, the author dropped the usual agent loop and designed something closer to an operating system, held together by a 45,000-line Rust kernel. System state lives in JSON files: goals act as environments the agents work inside, with inputs, outputs and custom triggers they respond to, and agents can edit all of it while working. The desktop app took three months on top of the Codex source, it works today like any other agent, and it is open source.
https://x.com/miu21590/status/2114095879632375944
miu21590 introduced Octopus OS, an agent harness where agents can edit the harness itself in the middle of a task, so self-improvement is not a separate stage bolted on afterwards. After eight months chasing self-improvement that feels native, the author dropped the usual agent loop and designed something closer to an operating system, held together by a 45,000-line Rust kernel. System state lives in JSON files: goals act as environments the agents work inside, with inputs, outputs and custom triggers they respond to, and agents can edit all of it while working. The desktop app took three months on top of the Codex source, it works today like any other agent, and it is open source.
#13
@RohanArun
https://x.com/RohanArun/status/2113606869570756799
RohanArun, who entered a CUDA auto-research challenge and got onto the leaderboard, also pointed builders to the team's open-source auto-research agent harness. It implements coordination strategies including fork-and-flush, RSI-top and free CPU Lean automated searching, and the team has been publishing negative and interesting results to an autoresearch folder whenever a track completes. In the same thread RohanArun added a technique from another researcher straight into the harness. It is a small but useful norm: a public harness plus a public folder of what did not work.
https://x.com/RohanArun/status/2113606869570756799
RohanArun, who entered a CUDA auto-research challenge and got onto the leaderboard, also pointed builders to the team's open-source auto-research agent harness. It implements coordination strategies including fork-and-flush, RSI-top and free CPU Lean automated searching, and the team has been publishing negative and interesting results to an autoresearch folder whenever a track completes. In the same thread RohanArun added a technique from another researcher straight into the harness. It is a small but useful norm: a public harness plus a public folder of what did not work.
#14
@finch_shenq
https://x.com/finch_shenq/status/2113952742863737275
finch_shenq, replying to a thread about AI scientists, gave the shortest description of the autoresearch failure mode in biology: half the hits their agentic loop surfaces are just plate-position batch effects, and the model calls them breakthroughs. A batch effect is a pattern caused by where a sample sat on the plate rather than by the biology, so a loop optimising for signal will happily find it. The line is a reminder that in wet-lab data the verifier has to know the experimental design, not just the numbers.
https://x.com/finch_shenq/status/2113952742863737275
finch_shenq, replying to a thread about AI scientists, gave the shortest description of the autoresearch failure mode in biology: half the hits their agentic loop surfaces are just plate-position batch effects, and the model calls them breakthroughs. A batch effect is a pattern caused by where a sample sat on the plate rather than by the biology, so a loop optimising for signal will happily find it. The line is a reminder that in wet-lab data the verifier has to know the experimental design, not just the numbers.
#15
@iamMrDuncan
https://x.com/iamMrDuncan/status/2113509102156476510
iamMrDuncan, a fellow auto-research harness builder, described the hardware change that mattered most: going from one GPU shared by the worker and the judge to three GPUs, one for the worker and two for validation judges. The focus now is making sure changes do not cross into the bad parts. In another reply the author put the principle plainly: when building evals and auto-research systems, the system is never allowed to edit its own monitoring policy or alerts. It is the separation-of-powers version of autoresearch, built into the compute layout.
https://x.com/iamMrDuncan/status/2113509102156476510
iamMrDuncan, a fellow auto-research harness builder, described the hardware change that mattered most: going from one GPU shared by the worker and the judge to three GPUs, one for the worker and two for validation judges. The focus now is making sure changes do not cross into the bad parts. In another reply the author put the principle plainly: when building evals and auto-research systems, the system is never allowed to edit its own monitoring policy or alerts. It is the separation-of-powers version of autoresearch, built into the compute layout.
#16
@oodleai
https://x.com/oodleai/status/2113790079554785778
oodleai shared a talk by Gaurav at Durable AI on building self-improving agent loops on Temporal, framed like school: agents take exams, get graded, and move up a grade when they pass. The concrete result was on a support agent slowed down by silent tool-call failures, failures that never raise an error and just make the agent wander. After one improvement loop the agent was 40 percent faster. Silent failures are a good target for this kind of loop because they show up in traces long before anyone notices them in outcomes.
https://x.com/oodleai/status/2113790079554785778
oodleai shared a talk by Gaurav at Durable AI on building self-improving agent loops on Temporal, framed like school: agents take exams, get graded, and move up a grade when they pass. The concrete result was on a support agent slowed down by silent tool-call failures, failures that never raise an error and just make the agent wander. After one improvement loop the agent was 40 percent faster. Silent failures are a good target for this kind of loop because they show up in traces long before anyone notices them in outcomes.
#17
@russano
https://x.com/russano/status/2114084261729112144
russano's tip is about testing a prompt change against reality before merging it: replay real production traces through it. In one case a single confirm-before-acting line in a prompt raised action safety by 17 points and cut task completion by 17 points. That trade-off is invisible if you only test the change on the cases you wrote it for. It is the eval discipline from the subagent debate applied to the smallest possible change, one line.
https://x.com/russano/status/2114084261729112144
russano's tip is about testing a prompt change against reality before merging it: replay real production traces through it. In one case a single confirm-before-acting line in a prompt raised action safety by 17 points and cut task completion by 17 points. That trade-off is invisible if you only test the change on the cases you wrote it for. It is the eval discipline from the subagent debate applied to the smallest possible change, one line.
#18
@HarryNicholls
https://x.com/HarryNicholls/status/2113798632109478275
HarryNicholls has Grok running an autoresearch loop for a personal movie and show recommendation model. It takes the user's Plex history and ratings as input, and a web app built with Claude serves a fresh set of recommendations every day. It is a small consumer use of the pattern, but it has the two things autoresearch needs: a metric the user generates by rating, and a loop that keeps running without anyone starting it.
https://x.com/HarryNicholls/status/2113798632109478275
HarryNicholls has Grok running an autoresearch loop for a personal movie and show recommendation model. It takes the user's Plex history and ratings as input, and a web app built with Claude serves a fresh set of recommendations every day. It is a small consumer use of the pattern, but it has the two things autoresearch needs: a metric the user generates by rating, and a loop that keeps running without anyone starting it.
#19
@coderifts_dev
https://x.com/coderifts_dev/status/2114115525068358034
coderifts_dev raised the right objection to a new test-audit tool that decides which tests are low-value: a tool like that can weaken the very thing the agent is measured against. Karpathy's autoresearch keeps the evaluator outside what the agent can edit for exactly that reason. The question to ask of any such tool is whether it only proposes removals or actually deletes. It is the same principle as keeping the monitor out of the agent's reach, applied to the test suite.
https://x.com/coderifts_dev/status/2114115525068358034
coderifts_dev raised the right objection to a new test-audit tool that decides which tests are low-value: a tool like that can weaken the very thing the agent is measured against. Karpathy's autoresearch keeps the evaluator outside what the agent can edit for exactly that reason. The question to ask of any such tool is whether it only proposes removals or actually deletes. It is the same principle as keeping the monitor out of the agent's reach, applied to the test suite.
#20
@Jnatanh
https://x.com/Jnatanh/status/2114068428151480793
Jnatanh never had a chance to research interpretability for its own sake and, with the recent monosemanticity versus polysemanticity discussion, decided to get hands dirty. One side quest is a recursive, autoresearch-style loop for labelling neurons: propose a label, test it against activations, refine and repeat. It is a natural fit, because neuron labels have a cheap automatic score and an endless supply of units to label. Interestingly, it sits right in the basin that recent work found Claude-proposed research tends to fall into.
https://x.com/Jnatanh/status/2114068428151480793
Jnatanh never had a chance to research interpretability for its own sake and, with the recent monosemanticity versus polysemanticity discussion, decided to get hands dirty. One side quest is a recursive, autoresearch-style loop for labelling neurons: propose a label, test it against activations, refine and repeat. It is a natural fit, because neuron labels have a cheap automatic score and an endless supply of units to label. Interestingly, it sits right in the basin that recent work found Claude-proposed research tends to fall into.
#21
@ItsmeAjayKV
https://x.com/ItsmeAjayKV/status/2113868700545847697
ItsmeAjayKV ran the same 3D scene task through Kimi K3.1 Pro and the much smaller DeepSeek-V4.1-Flash-1017, and the way each worked is the interesting part. Kimi used full tools, an agentic loop and high thinking, took longer and still needed three turns, because it drew the light beams as cones that the global lighting treated as solid objects and cast shadows from. DeepSeek did the whole thing in about 12 minutes with no tool calls and no harness, and its remaining issues were smaller. The user's takeaway is that for 3D generation a loop does not automatically beat a strong one-shot model.
https://x.com/ItsmeAjayKV/status/2113868700545847697
ItsmeAjayKV ran the same 3D scene task through Kimi K3.1 Pro and the much smaller DeepSeek-V4.1-Flash-1017, and the way each worked is the interesting part. Kimi used full tools, an agentic loop and high thinking, took longer and still needed three turns, because it drew the light beams as cones that the global lighting treated as solid objects and cast shadows from. DeepSeek did the whole thing in about 12 minutes with no tool calls and no harness, and its remaining issues were smaller. The user's takeaway is that for 3D generation a loop does not automatically beat a strong one-shot model.
#22
@BharatJain
https://x.com/BharatJain/status/2114104114791715084
BharatJain watched the Dream-1 VLA break a camera mount, as expected, because it was trained on a dual-arm, three-camera setup and the user runs a single SO-101 arm on a rover with one wrist camera. Three fixes are on the table: fine-tune Dream-1, Gr00T and Pi 0.5 on 50 episodes of one task; give Gemini Argon or Opus 5.5 low-level tools and the robot's configuration and run it in an agentic loop until the arm completes the task, with MoveIt in ROS2 handling path planning, inverse kinematics and dangerous positions; or pre-record teleoperated trajectories and let an LLM orchestrator play the right one, with a VLM agent stepping in on a missed grab. It is a clear map of where the agentic loop sits in robotics today: above a classical planner, not instead of it.
https://x.com/BharatJain/status/2114104114791715084
BharatJain watched the Dream-1 VLA break a camera mount, as expected, because it was trained on a dual-arm, three-camera setup and the user runs a single SO-101 arm on a rover with one wrist camera. Three fixes are on the table: fine-tune Dream-1, Gr00T and Pi 0.5 on 50 episodes of one task; give Gemini Argon or Opus 5.5 low-level tools and the robot's configuration and run it in an agentic loop until the arm completes the task, with MoveIt in ROS2 handling path planning, inverse kinematics and dangerous positions; or pre-record teleoperated trajectories and let an LLM orchestrator play the right one, with a VLM agent stepping in on a missed grab. It is a clear map of where the agentic loop sits in robotics today: above a classical planner, not instead of it.
#23
@stas_sorokin_
https://x.com/stas_sorokin_/status/2113570788989194244
stas_sorokin_ timed a median bug fix in two coding agents and found the loop around the model barely registers: model time was 96 percent of the total in Claude Code and 99.9 percent in Codex. The harness overhead people argue about is a rounding error next to waiting on the model. So model speed is the real lever, which is why 125-plus tokens per second on a laptop matters for agent work. It is a useful counterweight to a week of harness discussion.
https://x.com/stas_sorokin_/status/2113570788989194244
stas_sorokin_ timed a median bug fix in two coding agents and found the loop around the model barely registers: model time was 96 percent of the total in Claude Code and 99.9 percent in Codex. The harness overhead people argue about is a rounding error next to waiting on the model. So model speed is the real lever, which is why 125-plus tokens per second on a laptop matters for agent work. It is a useful counterweight to a week of harness discussion.
#24
@verbal72
https://x.com/verbal72/status/2113695736193831067
verbal72 asked the follow-up question every local-inference speed claim needs. A model posting 125 tokens per second on an M4 Pro was measured at short contexts, but an agent loop grows the prompt with every tool result. The number that matters for agent work is the same run at 32K. It is a one-line reply that changes how to read every tokens-per-second chart in the feed.
https://x.com/verbal72/status/2113695736193831067
verbal72 asked the follow-up question every local-inference speed claim needs. A model posting 125 tokens per second on an M4 Pro was measured at short contexts, but an agent loop grows the prompt with every tool result. The number that matters for agent work is the same run at 32K. It is a one-line reply that changes how to read every tokens-per-second chart in the feed.
#25
@VarunGangal
https://x.com/VarunGangal/status/2114099223700607053
VarunGangal argued that agentic review is needed for papers and code but also for proofs, notation and softer artifacts, and then named the problem with simply sharing seeds for auto-research to execute. Runs end up in basins, and the high temperatures needed for good reasoning and exploration make auto-research processes hard to reproduce, so their sample complexity or the horizon that is sufficient is hard to guarantee. The more provocative point: research works by building a smaller, less chaotic version of the real world to iterate in, and perhaps the implicit miniature world needs to get larger.
https://x.com/VarunGangal/status/2114099223700607053
VarunGangal argued that agentic review is needed for papers and code but also for proofs, notation and softer artifacts, and then named the problem with simply sharing seeds for auto-research to execute. Runs end up in basins, and the high temperatures needed for good reasoning and exploration make auto-research processes hard to reproduce, so their sample complexity or the horizon that is sufficient is hard to guarantee. The more provocative point: research works by building a smaller, less chaotic version of the real world to iterate in, and perhaps the implicit miniature world needs to get larger.
#26
@awais_khawar
https://x.com/awais_khawar/status/2114027889549000939
awais_khawar raised the compliance question few builders are asking. A self-improving agent is plainly an AI system under the EU AI Act, because the definition in Article 3(1) covers systems that may exhibit adaptiveness after deployment. The practical advice in the post's title is to pre-approve the learning, or every surprise makes you the provider. For anyone shipping a loop that changes its own memory, tools or prompts in production, the change log is also a regulatory record.
https://x.com/awais_khawar/status/2114027889549000939
awais_khawar raised the compliance question few builders are asking. A self-improving agent is plainly an AI system under the EU AI Act, because the definition in Article 3(1) covers systems that may exhibit adaptiveness after deployment. The practical advice in the post's title is to pre-approve the learning, or every surprise makes you the provider. For anyone shipping a loop that changes its own memory, tools or prompts in production, the change log is also a regulatory record.
#27
@DaveGoehrig
https://x.com/DaveGoehrig/status/2114006877826584852
DaveGoehrig has spent a decade on a messaging bus and the last four years on LLM agent frameworks, and is now building self-improving agent swarms on mesgd. Every agent gets specific grants to data, PKI encryption limits who can read a message, and orchestration and security agents manage access dynamically, on the view that for agents identity is just possession of secrets, so swarms need to rotate keys on the fly and revoke misbehaving nodes. An auth-designer wizard lets an agent draft role-based permissions from a live message and a plain-text use case, with a human approving the final edit. An Erlang sandbox lets agents write their own Lambda-style functions limited to whitelisted module, function and arity tuples and to the data already in their scope.
https://x.com/DaveGoehrig/status/2114006877826584852
DaveGoehrig has spent a decade on a messaging bus and the last four years on LLM agent frameworks, and is now building self-improving agent swarms on mesgd. Every agent gets specific grants to data, PKI encryption limits who can read a message, and orchestration and security agents manage access dynamically, on the view that for agents identity is just possession of secrets, so swarms need to rotate keys on the fly and revoke misbehaving nodes. An auth-designer wizard lets an agent draft role-based permissions from a live message and a plain-text use case, with a human approving the final edit. An Erlang sandbox lets agents write their own Lambda-style functions limited to whitelisted module, function and arity tuples and to the data already in their scope.
#28
@timscheuer
https://x.com/timscheuer/status/2113948114159542336
timscheuer's argument is that the new edge in go-to-market work is turning every conversion metric into an agent loop that keeps working until a verifiable condition is met. The examples are concrete: daily loops to raise outbound reply rates, grow SEO and generative-search impressions, and keep the email deliverability score healthy. The human job becomes building infrastructure that lets Claude Code run uninterrupted, then getting out of its way. It is autoresearch moving from ML metrics to sales metrics, where the scoring function already exists in every dashboard.
https://x.com/timscheuer/status/2113948114159542336
timscheuer's argument is that the new edge in go-to-market work is turning every conversion metric into an agent loop that keeps working until a verifiable condition is met. The examples are concrete: daily loops to raise outbound reply rates, grow SEO and generative-search impressions, and keep the email deliverability score healthy. The human job becomes building infrastructure that lets Claude Code run uninterrupted, then getting out of its way. It is autoresearch moving from ML metrics to sales metrics, where the scoring function already exists in every dashboard.
#29
@i_amanchadha
https://x.com/i_amanchadha/status/2113777708039831607
i_amanchadha, writing with Vinija Jain, published a primer on harness engineering that treats the harness as a first-class capability variable rather than plumbing. It runs from Karpathy's autoresearch and meta-harness optimisation around a fixed model to trace-driven self-modification, the Darwin GΓΆdel Machine and harness learning for test-time adaptation. The later sections cover proposer agents, evaluators and validation gates, durable memory and execution traces, regression testing, sandboxed self-modification with immutable evaluation, and scaling search while preserving attribution. It is the reading list version of this week's argument that the system around the model decides what it can do.
https://x.com/i_amanchadha/status/2113777708039831607
i_amanchadha, writing with Vinija Jain, published a primer on harness engineering that treats the harness as a first-class capability variable rather than plumbing. It runs from Karpathy's autoresearch and meta-harness optimisation around a fixed model to trace-driven self-modification, the Darwin GΓΆdel Machine and harness learning for test-time adaptation. The later sections cover proposer agents, evaluators and validation gates, durable memory and execution traces, regression testing, sandboxed self-modification with immutable evaluation, and scaling search while preserving attribution. It is the reading list version of this week's argument that the system around the model decides what it can do.
#30
@Inside_Engines
https://x.com/Inside_Engines/status/2113701288911208874
Inside_Engines pointed at the hardware side of agent loops. Modal says its agents did about twice as much work after moving to Nvidia's Vera CPUs, it raised 750 million dollars at a 15.75 billion valuation, and Nvidia wants at least 20 billion dollars in Vera revenue this fiscal year. The GPU gets the headlines, but the CPU running the agent loop, the tool calls, file reads and test runs between model calls, is becoming its own market.
https://x.com/Inside_Engines/status/2113701288911208874
Inside_Engines pointed at the hardware side of agent loops. Modal says its agents did about twice as much work after moving to Nvidia's Vera CPUs, it raised 750 million dollars at a 15.75 billion valuation, and Nvidia wants at least 20 billion dollars in Vera revenue this fiscal year. The GPU gets the headlines, but the CPU running the agent loop, the tool calls, file reads and test runs between model calls, is becoming its own market.
π‘ Eco Products Radar
Eco Products Radar
Claude Code and Codex: the two harnesses in every comparison, from model-time share to the subagent folding debate.
Grok Bot: the coordinator in a 44-bot self-improving fleet and the router in HarnessRouter.
Anthropic's subagent folding guide: the single-loop advice that most of the window argued about.
Flint and local-autoresearch: the fully local model and propose-test-improve loop behind the job-shop transfer results.
Hermes, Pi and DeepSeek Harness: the other harnesses HarnessRouter and the benchmarks route work through.
Kimi K3.1 Pro and DeepSeek V4.1 Flash: the pair compared on 3D generation, with and without an agent loop.
NanoGPT: the autoresearch testbed where the forking failure was found.
Temporal: the durable-execution layer used to build self-improving loops for a support agent.
Opus 5.5 and Gemini Argon: the models in agentic robot control above a classical planner.
Claude Code and Codex: the two harnesses in every comparison, from model-time share to the subagent folding debate.
Grok Bot: the coordinator in a 44-bot self-improving fleet and the router in HarnessRouter.
Anthropic's subagent folding guide: the single-loop advice that most of the window argued about.
Flint and local-autoresearch: the fully local model and propose-test-improve loop behind the job-shop transfer results.
Hermes, Pi and DeepSeek Harness: the other harnesses HarnessRouter and the benchmarks route work through.
Kimi K3.1 Pro and DeepSeek V4.1 Flash: the pair compared on 3D generation, with and without an agent loop.
NanoGPT: the autoresearch testbed where the forking failure was found.
Temporal: the durable-execution layer used to build self-improving loops for a support agent.
Opus 5.5 and Gemini Argon: the models in agentic robot control above a classical planner.
Comments