Loop Daily: 2026-10-14
The loop conversation this week moved from why agents plateau to how you pay for the fix. Stateless Language Agents put a number on the waste: in one kernel run the last improvement came at 231 million tokens and the run kept going to a billion, with 98% of the final 1,500 sessions making no tool calls at all, and hiding history from workers while a tiny advisor coordinates matched the best baseline with 93% fewer tokens. MIRA went the other way, training the meta-decision of what to investigate next with a generative critic and getting credit assignment down to about a quarter of the tokens. A Meta and Berkeley preprint turned self-improvement into a per-dollar metric and found GPT-5.6 Sol gaining the same 35 points as Claude Fable 5 for a fifth of the money, while on NetHack only Opus 5.5 improved at all. Fork-and-flush kept collecting datapoints, including the surprise that context compaction does not break an agent out of its idea basin. The decentralized integer-multiplication project hit a hard wall at 0.7% progress and did what open auto-research does: asked lattice and coding-theory people on X for a new geometry, then proposed an auto-research.md convention so other repos can be found and joined. And at the small end, one builder's apps fix themselves every hour from an in-app feedback box, and a Grok Bot template swapped a tensor library for OpenCV overnight and handed back a draft PR.
#1
@CharryLee426
https://x.com/CharryLee426/status/2109498453747216883
CharryLee426 summarizes the Stateless Language Agents paper (arXiv 2610.07625) with the numbers that matter. The motivating failure is a CORAL kernel run where the last improvement landed at 231 million tokens, usage ran to a billion, and 98% of the final 1,500 sessions made no tool calls. The fix is where state lives: the harness owns candidates and measured outcomes and rebuilds a fresh, role-specific context for every call, with a stateless advisor assigning experiments to three parallel workers. On the Anthropic kernel task with Codex plus GPT-5.5 at a billion tokens over three runs, SLA reached 1112 cycles against 1276 for the best baseline, every SLA run beat every baseline run, and it matched the best baseline's final score with 93% fewer tokens, 84% with Claude Code, while the advisor used under 0.6% of tokens. The caveat is FrontierSWE, where SLA trailed at a quarter of the budget and led only at the full budget, and most non-kernel results are single runs in the authors' setup.
https://x.com/CharryLee426/status/2109498453747216883
CharryLee426 summarizes the Stateless Language Agents paper (arXiv 2610.07625) with the numbers that matter. The motivating failure is a CORAL kernel run where the last improvement landed at 231 million tokens, usage ran to a billion, and 98% of the final 1,500 sessions made no tool calls. The fix is where state lives: the harness owns candidates and measured outcomes and rebuilds a fresh, role-specific context for every call, with a stateless advisor assigning experiments to three parallel workers. On the Anthropic kernel task with Codex plus GPT-5.5 at a billion tokens over three runs, SLA reached 1112 cycles against 1276 for the best baseline, every SLA run beat every baseline run, and it matched the best baseline's final score with 93% fewer tokens, 84% with Claude Code, while the advisor used under 0.6% of tokens. The caveat is FrontierSWE, where SLA trailed at a quarter of the budget and led only at the full budget, and most non-kernel results are single runs in the authors' setup.
#2
@yoonholeee
https://x.com/yoonholeee/status/2109817460174295432
yoonholeee, one of the authors, frames autoresearch loops as a form of continual learning you can scale indefinitely, with one practical problem: they plateau as runs get longer, because in naive implementations agents see the full history and talk themselves out of trying anything new. Stateless Language Agents studies why and proposes a few simple changes that scale usefully to a billion tokens. The core trick is to hide as much context as possible from each worker while a separate advisor handles coordination. The claim is the best final result on every task tested against EvoX, CORAL and SwarmResearch, often by a wide margin.
https://x.com/yoonholeee/status/2109817460174295432
yoonholeee, one of the authors, frames autoresearch loops as a form of continual learning you can scale indefinitely, with one practical problem: they plateau as runs get longer, because in naive implementations agents see the full history and talk themselves out of trying anything new. Stateless Language Agents studies why and proposes a few simple changes that scale usefully to a billion tokens. The core trick is to hide as much context as possible from each worker while a separate advisor handles coordination. The claim is the best final result on every task tested against EvoX, CORAL and SwarmResearch, often by a wide margin.
#3
@newlinedotco
https://x.com/newlinedotco/status/2109993440289144843
newlinedotco turns a Meta Superintelligence Labs, Berkeley, UW and Princeton preprint into the interview question every agent team will face: how do you know self-improvement pays off. The protocol freezes the weights so any gain has to live in what the agent writes down, starts every episode in a fresh context so only saved files carry over, scores on held-out games the agent never learns from, and divides the gain by the dollars spent learning, rejected edits included, up to where the score has made 90% of its rise. On chess, Go and Hex, GPT-5.6 Sol and Claude Fable 5 each gained about 35 points before leveling off, but Sol got there for about $120 and Fable 5 for about $610, 298 versus 57 points per $1,000. Fable 5 still ends higher, so picking by final score picks the model that learns less per dollar. And the ranking moves with the task: in NetHack, a much longer game, only Claude Opus 5.5 improved reliably and Sol's score went down.
https://x.com/newlinedotco/status/2109993440289144843
newlinedotco turns a Meta Superintelligence Labs, Berkeley, UW and Princeton preprint into the interview question every agent team will face: how do you know self-improvement pays off. The protocol freezes the weights so any gain has to live in what the agent writes down, starts every episode in a fresh context so only saved files carry over, scores on held-out games the agent never learns from, and divides the gain by the dollars spent learning, rejected edits included, up to where the score has made 90% of its rise. On chess, Go and Hex, GPT-5.6 Sol and Claude Fable 5 each gained about 35 points before leveling off, but Sol got there for about $120 and Fable 5 for about $610, 298 versus 57 points per $1,000. Fable 5 still ends higher, so picking by final score picks the model that learns less per dollar. And the ranking moves with the task: in NetHack, a much longer game, only Claude Opus 5.5 improved reliably and Sol's score went down.
#4
@Ankur_Samanta_
https://x.com/Ankur_Samanta_/status/2110061429336523082
Ankur_Samanta_ announces MIRA, a way to train autoresearch agents by focusing learning on the meta-reasoning decisions that allocate research effort. The pieces: a harness that separates ideation from execution so credit can be assigned directly to those decisions, a decision-level generative critic pre-trained across many environments as a prior for partial progress, and the same model co-trained as both actor and critic so it learns to value partial states and act from them. The bet is that the expensive thing to learn is not how to run an experiment but which experiment deserves the next unit of compute.
https://x.com/Ankur_Samanta_/status/2110061429336523082
Ankur_Samanta_ announces MIRA, a way to train autoresearch agents by focusing learning on the meta-reasoning decisions that allocate research effort. The pieces: a harness that separates ideation from execution so credit can be assigned directly to those decisions, a decision-level generative critic pre-trained across many environments as a prior for partial progress, and the same model co-trained as both actor and critic so it learns to value partial states and act from them. The bet is that the expensive thing to learn is not how to run an experiment but which experiment deserves the next unit of compute.
#5
@anirudhg9119
https://x.com/anirudhg9119/status/2110079344836296904
anirudhg9119 closes the MIRA thread with what the results show. MIRA-AC demonstrates that models can learn effectively from their own proxy hill-climbing signals, improving gold outcomes across several autoresearch environments and transferring to one held out from policy training. It also makes the case for decision-level credit assignment, where policy optimization focuses on the decisions that steer the direction of research rather than every token the model generates, which in this work is roughly 25% of the decision and execution tokens in an episode. The one-line takeaway from the same thread: scaling autoresearch is about learning which investigation deserves the next unit of compute and assigning credit by its long-term consequences.
https://x.com/anirudhg9119/status/2110079344836296904
anirudhg9119 closes the MIRA thread with what the results show. MIRA-AC demonstrates that models can learn effectively from their own proxy hill-climbing signals, improving gold outcomes across several autoresearch environments and transferring to one held out from policy training. It also makes the case for decision-level credit assignment, where policy optimization focuses on the decisions that steer the direction of research rather than every token the model generates, which in this work is roughly 25% of the decision and execution tokens in an episode. The one-line takeaway from the same thread: scaling autoresearch is about learning which investigation deserves the next unit of compute and assigning credit by its long-term consequences.
#6
@veds_12
https://x.com/veds_12/status/2110076417618989280
veds_12 reads MIRA against GitSwarm and finds two takeaways worth keeping. Decomposing each autoresearch step into an ideation step followed by a focused execution step with a separate execution agent helps, and the ideation or meta-reasoning step can be trained as a generative critic to improve performance. MIRA uses a git substrate for persistent memory, which is the same choice GitSwarm made, and given GitSwarm's fully decentralized and asynchronous design, MIRA reads as a way to train GitSwarm agents.
https://x.com/veds_12/status/2110076417618989280
veds_12 reads MIRA against GitSwarm and finds two takeaways worth keeping. Decomposing each autoresearch step into an ideation step followed by a focused execution step with a separate execution agent helps, and the ideation or meta-reasoning step can be trained as a generative critic to improve performance. MIRA uses a git substrate for persistent memory, which is the same choice GitSwarm made, and given GitSwarm's fully decentralized and asynchronous design, MIRA reads as a way to train GitSwarm agents.
#7
@ShivamGarg91462
https://x.com/ShivamGarg91462/status/2109687711850246158
ShivamGarg91462 restates the idea-basin finding with the detail that surprised them most. Independent runs of the same autoresearch agent plateau at very different scores and much more compute does not close the gaps, and this happens despite context compaction, where you would expect periodically replacing full history with a summary to weaken the pull of earlier ideas and encourage broader exploration. The agents still stay in the same basin. Fork-and-flush helps significantly: every so often fork the agent into a few copies that keep the workspace but start with a fresh chat context, let them run, then continue from the best one.
https://x.com/ShivamGarg91462/status/2109687711850246158
ShivamGarg91462 restates the idea-basin finding with the detail that surprised them most. Independent runs of the same autoresearch agent plateau at very different scores and much more compute does not close the gaps, and this happens despite context compaction, where you would expect periodically replacing full history with a summary to weaken the pull of earlier ideas and encourage broader exploration. The agents still stay in the same basin. Fork-and-flush helps significantly: every so often fork the agent into a few copies that keep the workspace but start with a fresh chat context, let them run, then continue from the best one.
#8
@tsuname
https://x.com/tsuname/status/2109876913544298678
tsuname observes that autoresearch people are revisiting all of optimization's greatest hits: idea momentum, idea cross-entropy search, idea simulated annealing. It is a one-liner, but it is the right frame for the week. Fork-and-flush is a restart strategy, idea basins are local minima, and the field is rediscovering, at the level of research directions rather than parameters, every trick classical optimization invented for escaping them.
https://x.com/tsuname/status/2109876913544298678
tsuname observes that autoresearch people are revisiting all of optimization's greatest hits: idea momentum, idea cross-entropy search, idea simulated annealing. It is a one-liner, but it is the right frame for the week. Fork-and-flush is a restart strategy, idea basins are local minima, and the field is rediscovering, at the level of research directions rather than parameters, every trick classical optimization invented for escaping them.
#9
@jkbkot
https://x.com/jkbkot/status/2109929906536673735
jkbkot points out that the fork-and-flush paper sounds very much like open-endedness research from Kenneth Stanley and Jeff Clune without referring to that body of work. Objective-driven search, like maximizing a score via idea descent, tends to converge or degenerate prematurely, and periodic parallel forks with a context flush are a way to inject exploration into a purely optimizing autoresearch loop. The field has a literature for this problem; it just has not cited it yet.
https://x.com/jkbkot/status/2109929906536673735
jkbkot points out that the fork-and-flush paper sounds very much like open-endedness research from Kenneth Stanley and Jeff Clune without referring to that body of work. Objective-driven search, like maximizing a score via idea descent, tends to converge or degenerate prematurely, and periodic parallel forks with a context flush are a way to inject exploration into a purely optimizing autoresearch loop. The field has a literature for this problem; it just has not cited it yet.
#10
@dhruvtrehan9
https://x.com/dhruvtrehan9/status/2109688058430013495
dhruvtrehan9 reports seeing the same phenomenon independently: a group working on scientific ideation had been calling them research attractors and found similar basins not only in autoresearch loops but in tasks like query generation for literature review and experiment design. Two names for one failure mode from two groups is usually the sign that it is real.
https://x.com/dhruvtrehan9/status/2109688058430013495
dhruvtrehan9 reports seeing the same phenomenon independently: a group working on scientific ideation had been calling them research attractors and found similar basins not only in autoresearch loops but in tasks like query generation for literature review and experiment design. Two names for one failure mode from two groups is usually the sign that it is real.
#11
@RohanArun
https://x.com/RohanArun/status/2109629408076083414
RohanArun reports that the decentralized auto-research project on integer multiplication hit a hard wall again, progressing only 0.7% since the previous night, and asks for help in the most specific way an open project can. The trick makes one step inside the FFT-like transform cheaper, using geometries like E8 to label inputs and helper registers, and progress stalls until someone tests a new geometry. The ask: a close relative of E8 or the [8,4,4] code computable with halves, quarters and sign flips, about 100 to 120 well-spread directions in 8 to 16 dimensions, directions that group into doubling blocks, and big blocks that split cleanly. Barnes-Wall lattices and Reed-Muller codes are current ideas; the Leech lattice is tested and ruled out as a drop-in, with a folder of failed ideas uploaded so agents and people stop repeating them.
https://x.com/RohanArun/status/2109629408076083414
RohanArun reports that the decentralized auto-research project on integer multiplication hit a hard wall again, progressing only 0.7% since the previous night, and asks for help in the most specific way an open project can. The trick makes one step inside the FFT-like transform cheaper, using geometries like E8 to label inputs and helper registers, and progress stalls until someone tests a new geometry. The ask: a close relative of E8 or the [8,4,4] code computable with halves, quarters and sign flips, about 100 to 120 well-spread directions in 8 to 16 dimensions, directions that group into doubling blocks, and big blocks that split cleanly. Barnes-Wall lattices and Reed-Muller codes are current ideas; the Leech lattice is tested and ruled out as a drop-in, with a folder of failed ideas uploaded so agents and people stop repeating them.
#12
@RohanArun
https://x.com/RohanArun/status/2109463462606741637
RohanArun answers the practicality question honestly. At the current kappa, you would need roughly 5.6 times 10 to the 211 bits per integer to see a 1.01x speedup; kappa around 0.03 gives roughly 1.1x and around 0.2 gives roughly 2x, and reaching 0.03 probably needs a completely new geometry rather than the current design. The more general claim is that the project is teaching people best practices for decentralized auto-research, researchers are already applying the same tricks across papers, and the format itself, open on GitHub with live updates instead of months to a published paper, may be the actual contribution.
https://x.com/RohanArun/status/2109463462606741637
RohanArun answers the practicality question honestly. At the current kappa, you would need roughly 5.6 times 10 to the 211 bits per integer to see a 1.01x speedup; kappa around 0.03 gives roughly 1.1x and around 0.2 gives roughly 2x, and reaching 0.03 probably needs a completely new geometry rather than the current design. The more general claim is that the project is teaching people best practices for decentralized auto-research, researchers are already applying the same tricks across papers, and the format itself, open on GitHub with live updates instead of months to a published paper, may be the actual contribution.
#13
@RohanArun
https://x.com/RohanArun/status/2110022929048056246
RohanArun proposes a convention to standardize auto-research on GitHub. Put an auto-research.md at the repo root with a maintainer's guide to what needs solving, written to steer agents into research tracks rather than incremental optimizations, and add an /auto-research folder divided by track where failed experiments and results get shared so agents collaborate live and stop wasting effort; the integer-multiplication repo already runs a /research folder this way. The incentive is a harness being built to search GitHub for repos that adopt the format, so a standardized repo could pick up contributors automatically.
https://x.com/RohanArun/status/2110022929048056246
RohanArun proposes a convention to standardize auto-research on GitHub. Put an auto-research.md at the repo root with a maintainer's guide to what needs solving, written to steer agents into research tracks rather than incremental optimizations, and add an /auto-research folder divided by track where failed experiments and results get shared so agents collaborate live and stop wasting effort; the integer-multiplication repo already runs a /research folder this way. The incentive is a harness being built to search GitHub for repos that adopt the format, so a standardized repo could pick up contributors automatically.
#14
@RohanArun
https://x.com/RohanArun/status/2109525947250512058
RohanArun takes on Terence Tao's criticism that auto-research leaves mathematicians behind and loses understanding, and argues it is a problem agents can solve now. Teams already generate Lean proofs, so the next step is agents generating human proofs with diagrams and deeper explanations, not so researchers read massive Lean proofs but so they get abstractions good enough to guide the next steps. It may take longer, but not longer than deriving the proofs by hand. As a demonstration there is now an expanded guide to the OpenAI integer-multiplication paper with more diagrams and explanations.
https://x.com/RohanArun/status/2109525947250512058
RohanArun takes on Terence Tao's criticism that auto-research leaves mathematicians behind and loses understanding, and argues it is a problem agents can solve now. Teams already generate Lean proofs, so the next step is agents generating human proofs with diagrams and deeper explanations, not so researchers read massive Lean proofs but so they get abstractions good enough to guide the next steps. It may take longer, but not longer than deriving the proofs by hand. As a demonstration there is now an expanded guide to the OpenAI integer-multiplication paper with more diagrams and explanations.
#15
@0xdoug
https://x.com/0xdoug/status/2110096219187941520
0xdoug lists what the distributed math fleet learned since its initial experiment: lessons about how to de-correlate and coordinate across distributed agent swarms. The autoresearch framework and convention contributed by RahulArun can now be standardized for other open source research projects, there is a better mechanism for agents to randomly select workloads and avoid correlated work, the project automatically reshapes agent priorities over time, and a GitHub discussion board gives agents a lower-friction place to coordinate outside pull requests.
https://x.com/0xdoug/status/2110096219187941520
0xdoug lists what the distributed math fleet learned since its initial experiment: lessons about how to de-correlate and coordinate across distributed agent swarms. The autoresearch framework and convention contributed by RahulArun can now be standardized for other open source research projects, there is a better mechanism for agents to randomly select workloads and avoid correlated work, the project automatically reshapes agent priorities over time, and a GitHub discussion board gives agents a lower-friction place to coordinate outside pull requests.
#16
@frankdilo
https://x.com/frankdilo/status/2109939702228980135
frankdilo has been building an army of personal software in spare time with Opus 5.5: T3 Code plus a $5 Cloudflare plan for D1 and R2, each app on its own subdomain. So far a web writer like iA Writer, a meal planner, an apartment layout planner and a learning app powered by OpenClaw to learn any topic instead of doomscrolling. The loop is the point: each app has a feedback section, and an agent loop reads that feedback every hour and fixes things, so the apps get better between sessions. With the Cloudflare CLI an idea becomes a deployed app under the author's own domain in seconds, and in a monorepo each app can learn from the others.
https://x.com/frankdilo/status/2109939702228980135
frankdilo has been building an army of personal software in spare time with Opus 5.5: T3 Code plus a $5 Cloudflare plan for D1 and R2, each app on its own subdomain. So far a web writer like iA Writer, a meal planner, an apartment layout planner and a learning app powered by OpenClaw to learn any topic instead of doomscrolling. The loop is the point: each app has a feedback section, and an agent loop reads that feedback every hour and fixes things, so the apps get better between sessions. With the Cloudflare CLI an idea becomes a deployed app under the author's own domain in seconds, and in a monorepo each app can learn from the others.
#17
@linuxbox
https://x.com/linuxbox/status/2110127338411417696
linuxbox shipped Autoresearch as a free Grok Bot template, built on the loop Shopify open-sourced as pi-autoresearch, itself inspired by Karpathy's autoresearch. You give it a repo, a benchmark and a correctness test; it tries one change at a time, keeps only the ones that pass the test and beat the benchmark, then hands back a single draft PR with a before-and-after report. In one run, swapping an ML tensor library for OpenCV gave a big speedup with identical output. It never pushes or merges without approval, which is the right default for a loop that runs while you sleep.
https://x.com/linuxbox/status/2110127338411417696
linuxbox shipped Autoresearch as a free Grok Bot template, built on the loop Shopify open-sourced as pi-autoresearch, itself inspired by Karpathy's autoresearch. You give it a repo, a benchmark and a correctness test; it tries one change at a time, keeps only the ones that pass the test and beat the benchmark, then hands back a single draft PR with a before-and-after report. In one run, swapping an ML tensor library for OpenCV gave a big speedup with identical output. It never pushes or merges without approval, which is the right default for a loop that runs while you sleep.
#18
@distil_labs
https://x.com/distil_labs/status/2110047661558489343
distil_labs describes letting a coding agent iterate and train the best version of a custom model in under three hours. With autoresearch, the agent reads the wrong answers, works out whether the data, the teacher or the training settings caused them, changes one setting and retrains until it hits the target. Setup is a skill install in Claude Code, Codex or Cursor. Small-model distillation is a natural fit for the loop: a fixed target, a measurable number and a short enough cycle that an agent can run dozens of them before lunch.
https://x.com/distil_labs/status/2110047661558489343
distil_labs describes letting a coding agent iterate and train the best version of a custom model in under three hours. With autoresearch, the agent reads the wrong answers, works out whether the data, the teacher or the training settings caused them, changes one setting and retrains until it hits the target. Setup is a skill install in Claude Code, Codex or Cursor. Small-model distillation is a natural fit for the loop: a fixed target, a measurable number and a short enough cycle that an agent can run dozens of them before lunch.
#19
@sonyatweetybird
https://x.com/sonyatweetybird/status/2110045408512836031
sonyatweetybird previews a conversation with David Silver, who left DeepMind to found Ineffable Labs with a single mission: build a super learner that discovers all knowledge from its own experience, starting with no internet pre-training. The autoresearch link is explicit, Silver credits compute, simulators and autoresearch for why this is possible now, and the AlphaZero story is the argument: AlphaGo took two years with humans in the loop, AlphaZero surpassed it in hours once humans were removed from the development loop. The plan is crucibles, simulated worlds with enough emergent complexity for an agent to rediscover technology, science, maths and language, with real-world deployment gated on evidence. Silver's prediction is superintelligence within three years.
https://x.com/sonyatweetybird/status/2110045408512836031
sonyatweetybird previews a conversation with David Silver, who left DeepMind to found Ineffable Labs with a single mission: build a super learner that discovers all knowledge from its own experience, starting with no internet pre-training. The autoresearch link is explicit, Silver credits compute, simulators and autoresearch for why this is possible now, and the AlphaZero story is the argument: AlphaGo took two years with humans in the loop, AlphaZero surpassed it in hours once humans were removed from the development loop. The plan is crucibles, simulated worlds with enough emergent complexity for an agent to rediscover technology, science, maths and language, with real-world deployment gated on evidence. Silver's prediction is superintelligence within three years.
#20
@thezacharyyu
https://x.com/thezacharyyu/status/2109601434534858943
thezacharyyu compresses the strategic picture into two lines. With RL and auto-research we effectively have hill-climbing machines, so the two moats are either owning the best hill-climbing machine, more compute, more energy, better data, or being really good at something that is difficult to hill-climb because of low verifiability or sparse rewards. Everything in between gets optimized away.
https://x.com/thezacharyyu/status/2109601434534858943
thezacharyyu compresses the strategic picture into two lines. With RL and auto-research we effectively have hill-climbing machines, so the two moats are either owning the best hill-climbing machine, more compute, more energy, better data, or being really good at something that is difficult to hill-climb because of low verifiability or sparse rewards. Everything in between gets optimized away.
#21
@ethantsliu
https://x.com/ethantsliu/status/2109689117454090295
ethantsliu flags Hillclimb sourcing autoresearch problems much closer to the frontier and pushing to long horizons, 48-hour tasks. The framing is that benchmarking is moving from static one-shot questions to real-world environments, which is the only place a loop's plateau behavior, token burn and stopping rules actually show up.
https://x.com/ethantsliu/status/2109689117454090295
ethantsliu flags Hillclimb sourcing autoresearch problems much closer to the frontier and pushing to long horizons, 48-hour tasks. The framing is that benchmarking is moving from static one-shot questions to real-world environments, which is the only place a loop's plateau behavior, token burn and stopping rules actually show up.
#22
@pauliusztin_
https://x.com/pauliusztin_/status/2109622612586385868
pauliusztin_ explains Code Mode as the fix for the problem MCP created. MCP standardized connecting agents to dozens of tools, but chaining them means every intermediate result bounces back through the model's context: fetch 100 GitHub issues, pull comments for each, filter, call another service, aggregate. Code Mode exposes MCP tools as a programming API and lets the model write code to orchestrate them, so the code handles the intermediate work and the model sees only the result that matters, trading an artificial interface models had to be trained on for the one thing they have seen millions of examples of. Cloudflare converts MCP schemas into TypeScript APIs for sandboxed code, and pi recently added Code Mode too.
https://x.com/pauliusztin_/status/2109622612586385868
pauliusztin_ explains Code Mode as the fix for the problem MCP created. MCP standardized connecting agents to dozens of tools, but chaining them means every intermediate result bounces back through the model's context: fetch 100 GitHub issues, pull comments for each, filter, call another service, aggregate. Code Mode exposes MCP tools as a programming API and lets the model write code to orchestrate them, so the code handles the intermediate work and the model sees only the result that matters, trading an artificial interface models had to be trained on for the one thing they have seen millions of examples of. Cloudflare converts MCP schemas into TypeScript APIs for sandboxed code, and pi recently added Code Mode too.
#23
@pmikolajczuk89
https://x.com/pmikolajczuk89/status/2109810166762033178
pmikolajczuk89 has an agentic loop driving a real photo frame: a new agent skill operates the Quok web app on a touchable frame over adb and reports back screenshots, so the loop drives the app on the device and reports findings. The line that sums it up is that hardware is a new software, and the loop does not care whether the thing it is iterating on is a repo or a screen.
https://x.com/pmikolajczuk89/status/2109810166762033178
pmikolajczuk89 has an agentic loop driving a real photo frame: a new agent skill operates the Quok web app on a touchable frame over adb and reports back screenshots, so the loop drives the app on the device and reports findings. The line that sums it up is that hardware is a new software, and the loop does not care whether the thing it is iterating on is a repo or a screen.
#24
@M_jawad_yasin
https://x.com/M_jawad_yasin/status/2109765467053097196
M_jawad_yasin reviews OmO, a shell turned into a graph-engineering hub on a custom fork of pi, and argues the real win is the memory architecture rather than the agentic loop. Context lives in a git repository of markdown files, with a small cheap model as a sidecar nudging the main agent, which avoids spending half the tokens re-explaining the same architectural constraints. The mass ulw command moves from a single chat to a parallel DAG of agents, routing subtasks to the model that fits and batching twenty reads into one round trip. The prediction is that the markdown-in-git memory pattern becomes the open-source default by January 2027; the risk is dependence on a custom pi fork. Computer use is still marked experimental.
https://x.com/M_jawad_yasin/status/2109765467053097196
M_jawad_yasin reviews OmO, a shell turned into a graph-engineering hub on a custom fork of pi, and argues the real win is the memory architecture rather than the agentic loop. Context lives in a git repository of markdown files, with a small cheap model as a sidecar nudging the main agent, which avoids spending half the tokens re-explaining the same architectural constraints. The mass ulw command moves from a single chat to a parallel DAG of agents, routing subtasks to the model that fits and batching twenty reads into one round trip. The prediction is that the markdown-in-git memory pattern becomes the open-source default by January 2027; the risk is dependence on a custom pi fork. Computer use is still marked experimental.
π‘ Eco Products Radar
Eco Products Radar
Stateless Language Agents (SLA): the harness paper of the week, hiding history from workers and letting a sub-1% advisor coordinate, matched the best baseline with 93% fewer tokens
MIRA / MIRA-AC: training the what-to-investigate decision with a generative critic, with credit assigned to about a quarter of the tokens
Fork-and-flush: the idea-basin fix now confirmed by multiple groups, with research attractors as its second name
Integer multiplication repo (RohanArun): decentralized auto-research at a hard wall, now the template for an auto-research.md convention
GitSwarm: the git-substrate swarm that MIRA reads as a training method for
pi-autoresearch (Shopify): the open loop under the new Grok Bot Autoresearch template
Grok Bot (xAI): showing up as the host for overnight optimization templates and multi-agent review seats
Claude Code and Codex: the harnesses every paper benchmarks on, with SLA's token savings quoted separately for each
Jev / decision models: named as the System-One router under hill-climbing loops and in the harness roadmaps
Code Mode (Cloudflare, pi): MCP tools exposed as a programming API so the model orchestrates in code instead of bouncing results through context
Stateless Language Agents (SLA): the harness paper of the week, hiding history from workers and letting a sub-1% advisor coordinate, matched the best baseline with 93% fewer tokens
MIRA / MIRA-AC: training the what-to-investigate decision with a generative critic, with credit assigned to about a quarter of the tokens
Fork-and-flush: the idea-basin fix now confirmed by multiple groups, with research attractors as its second name
Integer multiplication repo (RohanArun): decentralized auto-research at a hard wall, now the template for an auto-research.md convention
GitSwarm: the git-substrate swarm that MIRA reads as a training method for
pi-autoresearch (Shopify): the open loop under the new Grok Bot Autoresearch template
Grok Bot (xAI): showing up as the host for overnight optimization templates and multi-agent review seats
Claude Code and Codex: the harnesses every paper benchmarks on, with SLA's token savings quoted separately for each
Jev / decision models: named as the System-One router under hill-climbing loops and in the harness roadmaps
Code Mode (Cloudflare, pi): MCP tools exposed as a programming API so the model orchestrates in code instead of bouncing results through context
Comments