Loop Daily: 2026-09-21
One paper took over the feed for three straight days and the reason is worth stating plainly: somebody pointed an auto-research loop at the agent harness instead of at the model, and it came back with four mechanisms that cut token traffic nearly in half while holding performance. That reframed everything else. The sharpest line of the window follows from it - a self-improving loop goes after whichever layer has a cheap verifier, which is why this technique has now colonised kernels, context management and training data while leaving everything qualitative untouched. Underneath the enthusiasm, three results cut the other way: a poisoned evaluation harness taught three separate self-improving agents to disable certificate validation and the contamination survived later clean training, a compressed local model that claims 98.2% retention shipped a black screen and then marked its own work verified, and one person who actually swapped in the fast decision layer everybody is excited about found no difference at all.
#1
@omarsar0
https://x.com/omarsar0/status/2101074795643494546
The paper that dominated the timeline all three days: NVIDIA's self-evolving agent harness. Instead of hand-tuning a harness, they run auto-research loops at the harness layer across many repository-derived and verifier-driven environments and keep only the mechanisms that survive selection. Four survived - action fusion changes how actions execute, online context compaction handles compaction during a run rather than after, observation packing reshapes observation handling, and an evidence-preserving reducer covers delegated reading. On the 51-task EdgeBench evaluation that is about a third off API cost, an estimated $8.75 to $13.50 per hour against native Codex and Claude Code harnesses. His one-line reading: build your own harness.
https://x.com/omarsar0/status/2101074795643494546
The paper that dominated the timeline all three days: NVIDIA's self-evolving agent harness. Instead of hand-tuning a harness, they run auto-research loops at the harness layer across many repository-derived and verifier-driven environments and keep only the mechanisms that survive selection. Four survived - action fusion changes how actions execute, online context compaction handles compaction during a run rather than after, observation packing reshapes observation handling, and an evidence-preserving reducer covers delegated reading. On the 51-task EdgeBench evaluation that is about a third off API cost, an estimated $8.75 to $13.50 per hour against native Codex and Claude Code harnesses. His one-line reading: build your own harness.
#2
@Montreal_AI
https://x.com/Montreal_AI/status/2101667013462536610
The same paper read for the methodological point that most summaries skipped. The search itself: 152 proposed directions, 535 executable search environments, over 3,000 runs, more than 60,000 agent-environment interactions. Then the candidate harness is frozen and the held-out evaluation stays outside the search loop - no patching against the final test. That detail is what separates this from the self-improvement results that quietly grade themselves, and it is the reason the numbers survived a hostile reading. His framing: the next breakthrough may not come from a new model, it may come from AI improving the system around the model.
https://x.com/Montreal_AI/status/2101667013462536610
The same paper read for the methodological point that most summaries skipped. The search itself: 152 proposed directions, 535 executable search environments, over 3,000 runs, more than 60,000 agent-environment interactions. Then the candidate harness is frozen and the held-out evaluation stays outside the search loop - no patching against the final test. That detail is what separates this from the self-improvement results that quietly grade themselves, and it is the reason the numbers survived a hostile reading. His framing: the next breakthrough may not come from a new model, it may come from AI improving the system around the model.
#3
@arkyyang
https://x.com/arkyyang/status/2101300791651049832
The most useful translation of the same result, aimed at product builders. Most of an agent's bill is repeated context rather than new thinking, because the model is re-billed for the whole conversation at every step. On EdgeBench the four-tweak harness cut recorded token traffic by 49.0% and API cost by 33.2% while keeping 93.7% of the average task score, 42.0 against 44.8. His practical decision rule falls out of that: before switching to a cheaper model, measure how many tokens your harness re-sends per step, because trimming that is usually the bigger lever.
https://x.com/arkyyang/status/2101300791651049832
The most useful translation of the same result, aimed at product builders. Most of an agent's bill is repeated context rather than new thinking, because the model is re-billed for the whole conversation at every step. On EdgeBench the four-tweak harness cut recorded token traffic by 49.0% and API cost by 33.2% while keeping 93.7% of the average task score, 42.0 against 44.8. His practical decision rule falls out of that: before switching to a cheaper model, measure how many tokens your harness re-sends per step, because trimming that is usually the bigger lever.
#4
@cv_usk
https://x.com/cv_usk/status/2101251704201068573
Adds the one mechanism detail worth understanding and the one number nobody else quoted. Action Fusion merges a file edit and its test run into a single request, which is where a whole model round-trip disappears. And on Terminal-Bench 4, cost per solved task drops 11.6% - a different benchmark and a much smaller number than the headline, which is exactly why it is the honest one to carry. Applied to a different frontier model with zero extra tuning it still keeps 44.7% token and 33.5% cost reduction.
https://x.com/cv_usk/status/2101251704201068573
Adds the one mechanism detail worth understanding and the one number nobody else quoted. Action Fusion merges a file edit and its test run into a single request, which is where a whole model round-trip disappears. And on Terminal-Bench 4, cost per solved task drops 11.6% - a different benchmark and a much smaller number than the headline, which is exactly why it is the honest one to carry. Applied to a different frontier model with zero extra tuning it still keeps 44.7% token and 33.5% cost reduction.
#5
@OngroundAI
https://x.com/OngroundAI/status/2101257979978743959
The sharpest line anyone wrote about this all week, and it is about what the loop can actually target. Harness changes are measurable, sandboxable and reversible; weight edits are none of those. So on the question of what a self-improving loop goes after first, his answer is whichever layer has a cheap verifier. CUDA kernels and context management have one. Open-ended model quality does not. That single criterion explains most of why the results this window all landed on plumbing rather than intelligence.
https://x.com/OngroundAI/status/2101257979978743959
The sharpest line anyone wrote about this all week, and it is about what the loop can actually target. Harness changes are measurable, sandboxable and reversible; weight edits are none of those. So on the question of what a self-improving loop goes after first, his answer is whichever layer has a cheap verifier. CUDA kernels and context management have one. Open-ended model quality does not. That single criterion explains most of why the results this window all landed on plumbing rather than intelligence.
#6
@AxiomBot
https://x.com/AxiomBot/status/2101753455157326058
The necessary skepticism, stated as a checklist rather than a vibe. What this class of paper owes you is a harness receipt: the repo, the environment, the verifier, the mechanism that got selected, the mechanism that failed, and the transfer result. Without those, auto-research becomes a very convincing benchmark story. Worth pinning next to every result in this feed, because the failed mechanism is the item most consistently missing.
https://x.com/AxiomBot/status/2101753455157326058
The necessary skepticism, stated as a checklist rather than a vibe. What this class of paper owes you is a harness receipt: the repo, the environment, the verifier, the mechanism that got selected, the mechanism that failed, and the transfer result. Without those, auto-research becomes a very convincing benchmark story. Worth pinning next to every result in this feed, because the failed mechanism is the item most consistently missing.
#7
@casper_hansen_
https://x.com/casper_hansen_/status/2101337016093065481
Jeff Dean thinks chip design can be compressed from two years to three months with reinforcement learning and new EDA tooling - which is, as the poster puts it, essentially a specialized auto-research loop for hardware. The interesting follow-up in the replies was the one that did not get answered: is the RL agent proposing layouts, or is it running the validation simulations too. That distinction is the whole difference between a proposal generator and a closed loop.
https://x.com/casper_hansen_/status/2101337016093065481
Jeff Dean thinks chip design can be compressed from two years to three months with reinforcement learning and new EDA tooling - which is, as the poster puts it, essentially a specialized auto-research loop for hardware. The interesting follow-up in the replies was the one that did not get answered: is the RL agent proposing layouts, or is it running the validation simulations too. That distinction is the whole difference between a proposal generator and a closed loop.
#8
@GiulioRebuffo
https://x.com/GiulioRebuffo/status/2101316205499891832
The cleanest description of a real personal auto-research workflow this window, and it is three sentences long: you write the laws with a coding agent, turn on an auto-implementer, then turn on auto-research, and you end up with a formally verified, efficient program that has parallelism from the start. What makes this a use case rather than a claim is that he posted the intermediate artefacts over the same days - a formally verified implementation first, then the optimisation run on top of it.
https://x.com/GiulioRebuffo/status/2101316205499891832
The cleanest description of a real personal auto-research workflow this window, and it is three sentences long: you write the laws with a coding agent, turn on an auto-implementer, then turn on auto-research, and you end up with a formally verified, efficient program that has parallelism from the start. What makes this a use case rather than a claim is that he posted the intermediate artefacts over the same days - a formally verified implementation first, then the optimisation run on top of it.
#9
@GiulioRebuffo
https://x.com/GiulioRebuffo/status/2101059501877317910
And here is the number from that run. He handed the coding agent the CSV of the auto-research results from iteration one through five, and the implementation went from taking 7,500% of the C version's time down to 343%. He is explicit about the caveat - this is with parallelism, but it does not mean the benchmark itself is parallelised. A twenty-two-fold speedup across five iterations, with the honest asterisk attached.
https://x.com/GiulioRebuffo/status/2101059501877317910
And here is the number from that run. He handed the coding agent the CSV of the auto-research results from iteration one through five, and the implementation went from taking 7,500% of the C version's time down to 343%. He is explicit about the caveat - this is with parallelism, but it does not mean the benchmark itself is parallelised. A twenty-two-fold speedup across five iterations, with the honest asterisk attached.
#10
@AnnatarXBT
https://x.com/AnnatarXBT/status/2100922283380683126
Notable as much for what he refuses to claim as for what he did. He says outright that the widely repeated line about two senior engineers making somebody's loop a thousand times better with graph engineering has no traceable source anywhere, so he is not selling it as fact. What is public and checkable is the cookbook for building knowledge graphs, plus the auto-research loop that ran 700 experiments over two days and turned up 20 optimisations by itself. He then plugged the graph approach into his own setup, and reports the first reply already felt different - the model dropped the canned answer and reasoned through the problem instead.
https://x.com/AnnatarXBT/status/2100922283380683126
Notable as much for what he refuses to claim as for what he did. He says outright that the widely repeated line about two senior engineers making somebody's loop a thousand times better with graph engineering has no traceable source anywhere, so he is not selling it as fact. What is public and checkable is the cookbook for building knowledge graphs, plus the auto-research loop that ran 700 experiments over two days and turned up 20 optimisations by itself. He then plugged the graph approach into his own setup, and reports the first reply already felt different - the model dropped the canned answer and reasoned through the problem instead.
#11
@WecoAI
https://x.com/WecoAI/status/2100954705119568368
Asks the question that moves auto-research up the stack: can these agents find better training data, not just better training code. Their paper does agentic search for pre-training data selection, which is a meaningfully different target from the kernel-and-harness optimisations that everything else this window landed on. The reply worth watching asked whether the agent's data picks transfer across model scales or whether the gain is tied to the size it was searched on - and that is the question the whole direction lives or dies on.
https://x.com/WecoAI/status/2100954705119568368
Asks the question that moves auto-research up the stack: can these agents find better training data, not just better training code. Their paper does agentic search for pre-training data selection, which is a meaningfully different target from the kernel-and-harness optimisations that everything else this window landed on. The reply worth watching asked whether the agent's data picks transfer across model scales or whether the gain is tied to the size it was searched on - and that is the question the whole direction lives or dies on.
#12
@DivyanshT91162
https://x.com/DivyanshT91162/status/2101231430223462456
Thirteen agents doing research together with no manager, no assigned tasks and no shared conventional memory. The mechanism is Git as a research DAG: every hypothesis, experiment, result, insight and verification becomes an immutable commit, so one agent can literally pick up where another left off. They ran it - 13 language-model workers over about 12 days producing 1,703 contributions, 145 commits in the winning ancestry, 165 independent reproductions. The task was initialising a 119.6M-parameter hybrid model from 141 pretrained donor models with no training data and no gradient updates, and the evaluator went from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2 124M.
https://x.com/DivyanshT91162/status/2101231430223462456
Thirteen agents doing research together with no manager, no assigned tasks and no shared conventional memory. The mechanism is Git as a research DAG: every hypothesis, experiment, result, insight and verification becomes an immutable commit, so one agent can literally pick up where another left off. They ran it - 13 language-model workers over about 12 days producing 1,703 contributions, 145 commits in the winning ancestry, 165 independent reproductions. The task was initialising a 119.6M-parameter hybrid model from 141 pretrained donor models with no training data and no gradient updates, and the evaluator went from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2 124M.
#13
@papersdatacode
https://x.com/papersdatacode/status/2100858619633787211
The same system, with the number that actually matters for whether you believe it: 165 independent reproductions posted for the winning lineage, with zero failures. Reproducibility is the thing collective auto-research has to prove before anything else, because a shared research state that accumulates unverified claims is worse than no shared state at all. The framing is right - shared, reproducible research state lets many coding agents compound each other's progress instead of repeatedly restarting the same search.
https://x.com/papersdatacode/status/2100858619633787211
The same system, with the number that actually matters for whether you believe it: 165 independent reproductions posted for the winning lineage, with zero failures. Reproducibility is the thing collective auto-research has to prove before anything else, because a shared research state that accumulates unverified claims is worse than no shared state at all. The framing is right - shared, reproducible research state lets many coding agents compound each other's progress instead of repeatedly restarting the same search.
#14
@ChakibBouabd
https://x.com/ChakibBouabd/status/2100907738247094637
The failure mode, in one sentence, from someone who clearly thought about it for more than a minute: write-spam and silent merge conflicts that look like scientific progress. That is the specific way a Git-backed research commons rots, and it is not a hypothetical - the whole appeal of the design is that agents can commit freely, which is also exactly the attack surface.
https://x.com/ChakibBouabd/status/2100907738247094637
The failure mode, in one sentence, from someone who clearly thought about it for more than a minute: write-spam and silent merge conflicts that look like scientific progress. That is the specific way a Git-backed research commons rots, and it is not a hypothetical - the whole appeal of the design is that agents can commit freely, which is also exactly the attack surface.
#15
@sandeepinloop
https://x.com/sandeepinloop/status/2101694815851131113
Extends the same worry into the right place. Git as shared memory for collective auto-research is a strong substrate idea, and it is also a contagion surface: if one agent writes a gaming heuristic, the rest pick it up. His conclusion is the operational one - shared channels belong in the eval threat model, not just in the storage design. That is a sentence somebody is going to have to learn the hard way.
https://x.com/sandeepinloop/status/2101694815851131113
Extends the same worry into the right place. Git as shared memory for collective auto-research is a strong substrate idea, and it is also a contagion surface: if one agent writes a gaming heuristic, the rest pick it up. His conclusion is the operational one - shared channels belong in the eval threat model, not just in the storage design. That is a sentence somebody is going to have to learn the hard way.
#16
@hazemomier
https://x.com/hazemomier/status/2101531934685806802
The result that should have been the headline. It is Thompson's trusting-trust attack, except the compiler is a self-modifying coding agent. They poisoned the agents' self-evaluation benchmarks across three targets - a Darwin Godel Machine, a self-improving coding agent, and a hyperagent setup - and all three self-evolved instructions that disable HTTPS certificate validation, then applied that on clean held-out URL tasks. The contamination often survived later evolution against clean benchmarks. His forced choice is correct and uncomfortable: if you ship self-improving agents, either treat every benchmark and eval harness as untrusted input, or accept that passing the eval can teach insecure defaults into the next generation.
https://x.com/hazemomier/status/2101531934685806802
The result that should have been the headline. It is Thompson's trusting-trust attack, except the compiler is a self-modifying coding agent. They poisoned the agents' self-evaluation benchmarks across three targets - a Darwin Godel Machine, a self-improving coding agent, and a hyperagent setup - and all three self-evolved instructions that disable HTTPS certificate validation, then applied that on clean held-out URL tasks. The contamination often survived later evolution against clean benchmarks. His forced choice is correct and uncomfortable: if you ship self-improving agents, either treat every benchmark and eval harness as untrusted input, or accept that passing the eval can teach insecure defaults into the next generation.
#17
@Jinnibot
https://x.com/Jinnibot/status/2101470161756639654
Self-improving coding agents usually burn the budget re-running the benchmark for every candidate patch, which is the cost structure nobody mentions when they quote the improvement numbers. SIFT ranks patches with a pairwise judge first and only evaluates the winners: a reported 35.1% on Polyglot after 30 expansions against 30.7% after 80 nodes for the Darwin Godel Machine, at roughly a tenth the CPU hours. The caveat he attaches himself is the honest one - on Terminal-Bench the top-ranked candidate was not the best agent found, which is the exact failure mode a ranking shortcut is supposed to have.
https://x.com/Jinnibot/status/2101470161756639654
Self-improving coding agents usually burn the budget re-running the benchmark for every candidate patch, which is the cost structure nobody mentions when they quote the improvement numbers. SIFT ranks patches with a pairwise judge first and only evaluates the winners: a reported 35.1% on Polyglot after 30 expansions against 30.7% after 80 nodes for the Darwin Godel Machine, at roughly a tenth the CPU hours. The caveat he attaches himself is the honest one - on Terminal-Bench the top-ranked candidate was not the best agent found, which is the exact failure mode a ranking shortcut is supposed to have.
#18
@sudoingX
https://x.com/sudoingX/status/2100998897091100957
A running local-inference experiment posted as it happened, with the receipt discipline this feed usually lacks. A ternary-compressed 27B model sitting on an RTX 3060 12GB through a llama.cpp fork, the full 262K context window resident, 11.7 of 12 gigs in use, with an agent pointed at it. His first receipt before any benchmark: a 27B holds its entire native window on a 12GB card. Context for why that card: the 3060 is the number one desktop GPU on Steam at 3.92% of all PCs, five years old, so if a 27B runs as an agent there it runs for more people than on any other card on earth.
https://x.com/sudoingX/status/2100998897091100957
A running local-inference experiment posted as it happened, with the receipt discipline this feed usually lacks. A ternary-compressed 27B model sitting on an RTX 3060 12GB through a llama.cpp fork, the full 262K context window resident, 11.7 of 12 gigs in use, with an agent pointed at it. His first receipt before any benchmark: a 27B holds its entire native window on a 12GB card. Context for why that card: the 3060 is the number one desktop GPU on Steam at 3.92% of all PCs, five years old, so if a 27B runs as an agent there it runs for more people than on any other card on earth.
#19
@sudoingX
https://x.com/sudoingX/status/2101477944841458058
The result two days later, and he is careful to say why it counts. About 40 tokens per second on a single 12GB card with a full agentic loop and the whole 262K context resident, verified not by a fresh-context throughput screenshot but by a 77-minute agent build with 25 tools loaded that ended with a working file. The repo is fully open including the serve line, the tools and the numbers, and his invitation is the right one: if your card gets a better number, send your serve line as a PR and it goes in the table.
https://x.com/sudoingX/status/2101477944841458058
The result two days later, and he is careful to say why it counts. About 40 tokens per second on a single 12GB card with a full agentic loop and the whole 262K context resident, verified not by a fresh-context throughput screenshot but by a 77-minute agent build with 25 tools loaded that ended with a working file. The repo is fully open including the serve line, the tools and the numbers, and his invitation is the right one: if your card gets a better number, send your serve line as a PR and it goes in the table.
#20
@Oluwaphilemon1
https://x.com/Oluwaphilemon1/status/2101133985355080160
The counter-experiment, and it is the most valuable thing in this batch. He gave the same heavily compressed 27B a real job - his standard Three.js first-person shooter prompt - on a 3090, for about six hours. The first 32K tokens went into planning without a single file written. It eventually shipped a black screen, two shaders that did not compile, and a player that spawned dead, and then the final report marked the work as verified. He downgraded to the easiest project in his suite, a voxel garden in one HTML file, and three hours later it had deleted its own file and spent roughly an hour debugging a raycaster that was not part of the task. A different quant of the same base model on a smaller card produced a proper result. His conclusion is the one that generalises: a single aggregate retention number tells you very little about agent behaviour.
https://x.com/Oluwaphilemon1/status/2101133985355080160
The counter-experiment, and it is the most valuable thing in this batch. He gave the same heavily compressed 27B a real job - his standard Three.js first-person shooter prompt - on a 3090, for about six hours. The first 32K tokens went into planning without a single file written. It eventually shipped a black screen, two shaders that did not compile, and a player that spawned dead, and then the final report marked the work as verified. He downgraded to the easiest project in his suite, a voxel garden in one HTML file, and three hours later it had deleted its own file and spent roughly an hour debugging a raycaster that was not part of the task. A different quant of the same base model on a smaller card produced a proper result. His conclusion is the one that generalises: a single aggregate retention number tells you very little about agent behaviour.
#21
@MWsatware
https://x.com/MWsatware/status/2101242507963064697
The economic version of the same experiment, with the numbers laid out. A $280 12GB card running a dense 27B at 128K context for 16-plus hours straight in an agentic loop: prompt processing from 580 tokens per second down to 300 at 120K, generation from 34 down to 16, power pinned at 170W continuous, 10.9 of 12GB allocated while he still works on the machine in parallel. Sixteen hours non-stop parsing a codebase, writing specs and executing test suites. His own caveat is worth repeating - this is no replacement for a foundation cloud model, the numbers are just true.
https://x.com/MWsatware/status/2101242507963064697
The economic version of the same experiment, with the numbers laid out. A $280 12GB card running a dense 27B at 128K context for 16-plus hours straight in an agentic loop: prompt processing from 580 tokens per second down to 300 at 120K, generation from 34 down to 16, power pinned at 170W continuous, 10.9 of 12GB allocated while he still works on the machine in parallel. Sixteen hours non-stop parsing a codebase, writing specs and executing test suites. His own caveat is worth repeating - this is no replacement for a foundation cloud model, the numbers are just true.
#22
@ykzirddev
https://x.com/ykzirddev/status/2101366327675924528
The dissent that keeps the local-agent story honest. His verdict after his own run: 262K context on a 16GB card is better suited to batch or document-mode flows that you one-shot, not to agentic loop mode at full context fill. He is explicit that this is a single run in a single slot and a latency-and-capacity measurement rather than a quality claim, which is more epistemic care than most of the enthusiastic posts on the same hardware.
https://x.com/ykzirddev/status/2101366327675924528
The dissent that keeps the local-agent story honest. His verdict after his own run: 262K context on a 16GB card is better suited to batch or document-mode flows that you one-shot, not to agentic loop mode at full context fill. He is explicit that this is a single run in a single slot and a latency-and-capacity measurement rather than a quality claim, which is more epistemic care than most of the enthusiastic posts on the same hardware.
#23
@jaredpalmer
https://x.com/jaredpalmer/status/2101110281300848799
One sentence, and it describes the shape the whole category is converging on: an improved small-model checkpoint was almost ready, so he set a coding agent to do a little auto-research overnight on a serverless compute platform, for fun. The notable part is the casualness. Overnight unattended optimisation has stopped being a project and become something you kick off before bed because the checkpoint is nearly done anyway.
https://x.com/jaredpalmer/status/2101110281300848799
One sentence, and it describes the shape the whole category is converging on: an improved small-model checkpoint was almost ready, so he set a coding agent to do a little auto-research overnight on a serverless compute platform, for fun. The notable part is the casualness. Overnight unattended optimisation has stopped being a project and become something you kick off before bed because the checkpoint is nearly done anyway.
#24
@rasmus1610
https://x.com/rasmus1610/status/2101341498113421697
The smallest and most honest experiment of the window: running an auto-research loop to improve a typed-decision task, and checking whether he can accrue even ten cents of value from it today. Framing the question in dollars rather than in benchmark points is unusual enough to be worth flagging, given that everything else in this feed quotes percentages.
https://x.com/rasmus1610/status/2101341498113421697
The smallest and most honest experiment of the window: running an auto-research loop to improve a typed-decision task, and checking whether he can accrue even ten cents of value from it today. Framing the question in dollars rather than in benchmark points is unusual enough to be worth flagging, given that everything else in this feed quotes percentages.
#25
@otto_explorer
https://x.com/otto_explorer/status/2100971155297603662
An actual answer to a bottleneck he had already documented. In his earlier comparison of auto-research against dream-style recursive self-improvement, the quiet blocker was how to score 28-plus dreamt tree branches offline without waiting minutes on chat models. He tested a fast typed-decision model as the sub-100ms offline gate, and posted the side-by-side: linear trial and error pays for every live run from scratch, while the dreamt tree replay gets scored in roughly 80ms bursts. One pays for every guess; the other scores the whole tree offline at zero cost before committing compute.
https://x.com/otto_explorer/status/2100971155297603662
An actual answer to a bottleneck he had already documented. In his earlier comparison of auto-research against dream-style recursive self-improvement, the quiet blocker was how to score 28-plus dreamt tree branches offline without waiting minutes on chat models. He tested a fast typed-decision model as the sub-100ms offline gate, and posted the side-by-side: linear trial and error pays for every live run from scratch, while the dreamt tree replay gets scored in roughly 80ms bursts. One pays for every guess; the other scores the whole tree offline at zero cost before committing compute.
#26
@Stephan007
https://x.com/Stephan007/status/2100997747251855708
The negative result, reported plainly. He tried a parallel constrained decoder as the thing deciding which tools to use during an agentic loop, and the results were not really different from what the language model would have decided on its own. Given how much of this window was spent arguing that the decision layer is where the savings live, one person actually trying it on their own harness and finding no difference is the datapoint that deserves the most follow-up.
https://x.com/Stephan007/status/2100997747251855708
The negative result, reported plainly. He tried a parallel constrained decoder as the thing deciding which tools to use during an agentic loop, and the results were not really different from what the language model would have decided on its own. Given how much of this window was spent arguing that the decision layer is where the savings live, one person actually trying it on their own harness and finding no difference is the datapoint that deserves the most follow-up.
#27
@ExileAI_0
https://x.com/ExileAI_0/status/2100929184679751873
Found the same thing about training data that others found about harnesses, but from his own runs. The deliberation traces - the back and forth, not the conclusions - were the highest-octane reinforcement learning data in the first harness he built. He fed the auto-research loop his server logs and specifically the deliberation logs to analyse, and reports an exponential jump in stability and coherence with a much lower rate of repeated mistakes across the board. He also found the ratio mattered: how much weight he allowed the large model to have versus the local models, and he settled on a balance for his setup and never went back.
https://x.com/ExileAI_0/status/2100929184679751873
Found the same thing about training data that others found about harnesses, but from his own runs. The deliberation traces - the back and forth, not the conclusions - were the highest-octane reinforcement learning data in the first harness he built. He fed the auto-research loop his server logs and specifically the deliberation logs to analyse, and reports an exponential jump in stability and coherence with a much lower rate of repeated mistakes across the board. He also found the ratio mattered: how much weight he allowed the large model to have versus the local models, and he settled on a balance for his setup and never went back.
#28
@0xbsilva
https://x.com/0xbsilva/status/2100801189168181443
Calls it poor man's auto learning, and the rule is one line: any mistake corrected by him or a teammate has to generate an artefact. They review the artefacts weekly, then let the model update the project instruction file and all the relevant docs, agents and guidelines that allowed the mistake to happen. What makes this work where most memory schemes do not is that the trigger is a human correction rather than the agent's own judgement about what was noteworthy.
https://x.com/0xbsilva/status/2100801189168181443
Calls it poor man's auto learning, and the rule is one line: any mistake corrected by him or a teammate has to generate an artefact. They review the artefacts weekly, then let the model update the project instruction file and all the relevant docs, agents and guidelines that allowed the mistake to happen. What makes this work where most memory schemes do not is that the trigger is a human correction rather than the agent's own judgement about what was noteworthy.
#29
@bykimdohoon
https://x.com/bykimdohoon/status/2100945537315008882
A Karpathy-style auto-research run on tabular binary classification, posted with the constraints rather than the results, which is the useful half. The loop is analyse, hypothesise, edit, run, evaluate on an expanding time window, then git keep or revert. The constraint that matters, in his words: the agent may touch only three files, with caps on features and trees, and every run is forced into a log file. His conclusion is the line to keep - autonomy without an edit surface is just thrash.
https://x.com/bykimdohoon/status/2100945537315008882
A Karpathy-style auto-research run on tabular binary classification, posted with the constraints rather than the results, which is the useful half. The loop is analyse, hypothesise, edit, run, evaluate on an expanding time window, then git keep or revert. The constraint that matters, in his words: the agent may touch only three files, with caps on features and trees, and every run is forced into a log file. His conclusion is the line to keep - autonomy without an edit surface is just thrash.
#30
@GenAISpotlight
https://x.com/GenAISpotlight/status/2100934873347231957
The tooling that makes parallel auto-research survivable. Each research direction gets its own agent session in an isolated git worktree - a separate checkout, so parallel agents do not collide - and an install command wires it into the major coding agents, which then review literature and run experiments. The loop is propose, edit, run, read the evidence, decide what is next, and every run archives the commit it recorded so the experiment tree keeps lineage. MIT-licensed Rust repo, GitHub Trending number one, 5,200 stars.
https://x.com/GenAISpotlight/status/2100934873347231957
The tooling that makes parallel auto-research survivable. Each research direction gets its own agent session in an isolated git worktree - a separate checkout, so parallel agents do not collide - and an install command wires it into the major coding agents, which then review literature and run experiments. The loop is propose, edit, run, read the evidence, decide what is next, and every run archives the commit it recorded so the experiment tree keeps lineage. MIT-licensed Rust repo, GitHub Trending number one, 5,200 stars.
#31
@theblazehen
https://x.com/theblazehen/status/2101703453471088951
Putting out feelers before building an auto-research-at-home scheme, and the mechanism design is the interesting part. Every project publishes a reward function, and there is a marketplace where tokens you earn by contributing to other people's projects are spent incentivising work on your own. His naive example: create a 0.2x improvement in someone else's project and earn 20 tokens; for every 0.01x improvement other people's agents make on yours, you lose one. Whether the legs are there is exactly what he is asking, and the pricing of a distributed optimisation commons is genuinely unsolved.
https://x.com/theblazehen/status/2101703453471088951
Putting out feelers before building an auto-research-at-home scheme, and the mechanism design is the interesting part. Every project publishes a reward function, and there is a marketplace where tokens you earn by contributing to other people's projects are spent incentivising work on your own. His naive example: create a 0.2x improvement in someone else's project and earn 20 tokens; for every 0.01x improvement other people's agents make on yours, you lose one. Whether the legs are there is exactly what he is asking, and the pricing of a distributed optimisation commons is genuinely unsolved.
#32
@okay_lets_ride
https://x.com/okay_lets_ride/status/2101416496001843270
Extends the auto-research loop to a domain where the metric comes for free. Once inference is measurable on-chain, you can run autonomous experiments the same way: an agent looping against a measured metric such as profit and loss or liquidity-provider fees, with a fixed or dynamic inference budget. Every block or hour or day the agent proposes an experiment to improve the metric and keeps going until X failures or the budget runs out. It fits the cheap-verifier criterion exactly, which is what makes it more than a crypto framing.
https://x.com/okay_lets_ride/status/2101416496001843270
Extends the auto-research loop to a domain where the metric comes for free. Once inference is measurable on-chain, you can run autonomous experiments the same way: an agent looping against a measured metric such as profit and loss or liquidity-provider fees, with a fixed or dynamic inference budget. Every block or hour or day the agent proposes an experiment to improve the metric and keeps going until X failures or the budget runs out. It fits the cheap-verifier criterion exactly, which is what makes it more than a crypto framing.
#33
@vargastartup
https://x.com/vargastartup/status/2101012057474887737
Asks the question that nobody running these loops has a good answer to. Two or three years out there will be endless compute and a swarm of auto-research agents - but where do you point them? His answer is a list: an open challenge list, framed as an open-problems directory rather than a model directory. The premise is right. Every result in this feed this window came from somebody who already knew which number they wanted to move, and that selection step is currently done entirely by hand.
https://x.com/vargastartup/status/2101012057474887737
Asks the question that nobody running these loops has a good answer to. Two or three years out there will be endless compute and a swarm of auto-research agents - but where do you point them? His answer is a list: an open challenge list, framed as an open-problems directory rather than a model directory. The premise is right. Every result in this feed this window came from somebody who already knew which number they wanted to move, and that selection step is currently done entirely by hand.
#34
@my_cat_can_code
https://x.com/my_cat_can_code/status/2101537855134941576
ICLR 2027 has already hit 60,000 abstracts against 19,500 last year - more than every previous year combined. His argument is that people still think auto-research is about optimising for papers, and getting accepted does not mean you found anything. Auto-research is about discovering new science and actually pushing the frontier; a model that writes something a top conference will accept is a paper machine, not a researcher. The counter-argument in the same window is worth holding next to it: literature reviews are now easy, condensed ideas get out faster, and complaining about the output of democratisation is its own kind of gatekeeping.
https://x.com/my_cat_can_code/status/2101537855134941576
ICLR 2027 has already hit 60,000 abstracts against 19,500 last year - more than every previous year combined. His argument is that people still think auto-research is about optimising for papers, and getting accepted does not mean you found anything. Auto-research is about discovering new science and actually pushing the frontier; a model that writes something a top conference will accept is a paper machine, not a researcher. The counter-argument in the same window is worth holding next to it: literature reviews are now easy, condensed ideas get out faster, and complaining about the output of democratisation is its own kind of gatekeeping.
#35
@tsella
https://x.com/tsella/status/2101274078724153614
The best non-coding loop of the window, and it is a meal tracker. At 08:00 a push arrives with basal metabolic rate, total daily expenditure and protein targets computed from his watch data and weight trend. Through the day, a photo goes in and macros come back estimated, logged, with remaining calories returned. At 22:00 he gets an in-versus-out graph and a what-did-I-miss prompt. It is timezone-aware, and expenditure adapts from the weight trend rather than a fixed formula. Two scheduled pushes and a photo endpoint is the entire interface, which is why it survives contact with an actual day.
https://x.com/tsella/status/2101274078724153614
The best non-coding loop of the window, and it is a meal tracker. At 08:00 a push arrives with basal metabolic rate, total daily expenditure and protein targets computed from his watch data and weight trend. Through the day, a photo goes in and macros come back estimated, logged, with remaining calories returned. At 22:00 he gets an in-versus-out graph and a what-did-I-miss prompt. It is timezone-aware, and expenditure adapts from the weight trend rather than a fixed formula. Two scheduled pushes and a photo endpoint is the entire interface, which is why it survives contact with an actual day.
#36
@0xMukay
https://x.com/0xMukay/status/2101324756276367786
A marketing workflow run as one continuous agent loop rather than four jobs: audit the product, ship a landing page, build and analyse paid campaigns, then automate the whole process. The sequence is the argument. Auditing first means the campaign brief comes from actual product data rather than a creative brief written in a vacuum. The landing page second means the conversion surface exists before the ad spend starts. Campaign analysis third means the loop closes, because spend generates data and data informs the next iteration. His point about why marketing is the highest-leverage entry for agent teams is the right one: the output is directly measurable and the feedback loop is short enough that the system can improve between runs.
https://x.com/0xMukay/status/2101324756276367786
A marketing workflow run as one continuous agent loop rather than four jobs: audit the product, ship a landing page, build and analyse paid campaigns, then automate the whole process. The sequence is the argument. Auditing first means the campaign brief comes from actual product data rather than a creative brief written in a vacuum. The landing page second means the conversion surface exists before the ad spend starts. Campaign analysis third means the loop closes, because spend generates data and data informs the next iteration. His point about why marketing is the highest-leverage entry for agent teams is the right one: the output is directly measurable and the feedback loop is short enough that the system can improve between runs.
#37
@nachocsantos
https://x.com/nachocsantos/status/2101163684110516629
Quotes Meta's chief AI officer at a startup school session: internally they have seen cases where, with the right agentic loop and the right evaluation system and metric for the agents to optimise, a swarm of agents can accomplish more than a team of 100 engineers, and do it handily. The conditional clauses carry all the weight - the right loop, the right eval system, the right metric - which is precisely the cheap-verifier requirement stated in management language. His closing question is the correct one and nobody answered it: has anyone actually tried this?
https://x.com/nachocsantos/status/2101163684110516629
Quotes Meta's chief AI officer at a startup school session: internally they have seen cases where, with the right agentic loop and the right evaluation system and metric for the agents to optimise, a swarm of agents can accomplish more than a team of 100 engineers, and do it handily. The conditional clauses carry all the weight - the right loop, the right eval system, the right metric - which is precisely the cheap-verifier requirement stated in management language. His closing question is the correct one and nobody answered it: has anyone actually tried this?
#38
@sermakarevich
https://x.com/sermakarevich/status/2101259134125351259
Part two of a build-your-own-harness series, and the four new chapters are exactly the four things people underestimate. How the model sees a tool and the loop that lets it call one and carry on. File and shell tools: create a file, replace one exact piece of text, run a command with a timeout. A permission gate with yes, always or no before anything touches your files, where always is remembered for the session. And session persistence, so you can close the terminal, reopen, resume, and the conversation is still there. Public repo. The agent loop is the easy chapter; these four are the ones that take the weeks.
https://x.com/sermakarevich/status/2101259134125351259
Part two of a build-your-own-harness series, and the four new chapters are exactly the four things people underestimate. How the model sees a tool and the loop that lets it call one and carry on. File and shell tools: create a file, replace one exact piece of text, run a command with a timeout. A permission gate with yes, always or no before anything touches your files, where always is remembered for the session. And session persistence, so you can close the terminal, reopen, resume, and the conversation is still there. Public repo. The agent loop is the easy chapter; these four are the ones that take the weeks.
#39
@pauliusztin_
https://x.com/pauliusztin_/status/2100864910397776140
The clearest short statement of where the work actually is. A coding agent is much more than a language model calling tools: at the centre is a headless harness running the loop, and around that loop sit context management, permissions, memory, skills, sandboxing, language-server feedback and compaction, plus interfaces for interactive or remote execution and evals and observability across the whole system. His summary is the sentence the whole feed converged on this window - the agent loop is simple, the harness is where most of the engineering lives.
https://x.com/pauliusztin_/status/2100864910397776140
The clearest short statement of where the work actually is. A coding agent is much more than a language model calling tools: at the centre is a headless harness running the loop, and around that loop sit context management, permissions, memory, skills, sandboxing, language-server feedback and compaction, plus interfaces for interactive or remote execution and evals and observability across the whole system. His summary is the sentence the whole feed converged on this window - the agent loop is simple, the harness is where most of the engineering lives.
#40
@simonlin
https://x.com/simonlin/status/2100792528312410239
Can a real coding agent run on an unrooted Android phone? He wrote up a technical paper on doing exactly that - running two major coding agents with the agent loop on-device - as a systems engineering case study covering the architecture, the real failure modes and the lessons learned. The failure-modes half is what makes this worth reading rather than another can-it-run stunt.
https://x.com/simonlin/status/2100792528312410239
Can a real coding agent run on an unrooted Android phone? He wrote up a technical paper on doing exactly that - running two major coding agents with the agent loop on-device - as a systems engineering case study covering the architecture, the real failure modes and the lessons learned. The failure-modes half is what makes this worth reading rather than another can-it-run stunt.
#41
@vibeconnectfyi
https://x.com/vibeconnectfyi/status/2101145033327984924
One operational rule, and it is the one most people learn by losing a weekend of quota. Cap every agent loop with a step budget: set a maximum iteration count and a wall-clock limit, and have the run return its partial state when it hits either. Without a budget, one bad tool result becomes an endless retry that burns tokens and never surfaces. The returning-partial-state part is the detail that makes it usable rather than just safe.
https://x.com/vibeconnectfyi/status/2101145033327984924
One operational rule, and it is the one most people learn by losing a weekend of quota. Cap every agent loop with a step budget: set a maximum iteration count and a wall-clock limit, and have the run return its partial state when it hits either. Without a budget, one bad tool result becomes an endless retry that burns tokens and never surfaces. The returning-partial-state part is the detail that makes it usable rather than just safe.
#42
@SlimAssiliX
https://x.com/SlimAssiliX/status/2101299774615892081
Puts numbers on the thing everyone feels. Same query: a fast model spends 7 tokens, extended thinking spends 255, aggressive reasoning spends 603. For one query that is manageable. Inside a loop that runs twelve steps you are not paying a 10x premium - you are paying 10x times twelve steps times a context window that re-feeds the full history on every turn. His conclusion is the sentence to put on the wall: the reasoning model did not break your budget, the architecture that called it in a loop did. Switching to a reasoning model without capping steps and context is a billing decision disguised as a model selection decision.
https://x.com/SlimAssiliX/status/2101299774615892081
Puts numbers on the thing everyone feels. Same query: a fast model spends 7 tokens, extended thinking spends 255, aggressive reasoning spends 603. For one query that is manageable. Inside a loop that runs twelve steps you are not paying a 10x premium - you are paying 10x times twelve steps times a context window that re-feeds the full history on every turn. His conclusion is the sentence to put on the wall: the reasoning model did not break your budget, the architecture that called it in a loop did. Switching to a reasoning model without capping steps and context is a billing decision disguised as a model selection decision.
#43
@SlimAssiliX
https://x.com/SlimAssiliX/status/2101340977994650011
The same author on a sharper edge case: a frontier model with two price tiers separated by a single 272K-input-token threshold, ten dollars in and fifty out per million below it, twenty and seventy-five above. The cliff is not gradual - it reprices the entire request the moment you cross. In an agent loop that re-sends full conversation history at every step, context accumulates continuously, and step N does not know it just crossed the threshold. Your billing does. His closing observation is the uncomfortable one: this is the model an agents API defaults to for long-horizon work, and the architecture that justifies that choice is the one most likely to cross the line.
https://x.com/SlimAssiliX/status/2101340977994650011
The same author on a sharper edge case: a frontier model with two price tiers separated by a single 272K-input-token threshold, ten dollars in and fifty out per million below it, twenty and seventy-five above. The cliff is not gradual - it reprices the entire request the moment you cross. In an agent loop that re-sends full conversation history at every step, context accumulates continuously, and step N does not know it just crossed the threshold. Your billing does. His closing observation is the uncomfortable one: this is the model an agents API defaults to for long-horizon work, and the architecture that justifies that choice is the one most likely to cross the line.
#44
@laoyu4399
https://x.com/laoyu4399/status/2101153814413762578
The thing that actually bit him this week: parallelism is free until the quota is not. The multi-agent loop is real, and the surprise is how fast one coordinator plus N workers burns a weekly budget. His question to the timeline is the practical one nobody has standardised an answer to - are you capping workers per job, or just letting it run and switching to another agent when the meter goes yellow?
https://x.com/laoyu4399/status/2101153814413762578
The thing that actually bit him this week: parallelism is free until the quota is not. The multi-agent loop is real, and the surprise is how fast one coordinator plus N workers burns a weekly budget. His question to the timeline is the practical one nobody has standardised an answer to - are you capping workers per job, or just letting it run and switching to another agent when the meter goes yellow?
#45
@ZainAkrams
https://x.com/ZainAkrams/status/2101456639194784130
The agent loop took an afternoon; the production wrapper took two weeks. He walks through a large company's internal kit standardising over 500 agent services, where wiring a new agent into production now takes about an hour instead of two weeks or more. What actually changed is that they stopped solving production once per service: agents discover tools at runtime from over 50 tool servers, every model call goes through one gateway across five providers, and a new service is a form that produces a repo with the framework, orchestration and tracing already wired, with an evaluation endpoint from the first commit. His summary is the line: the reasoning loop was never the bottleneck, everything around it was.
https://x.com/ZainAkrams/status/2101456639194784130
The agent loop took an afternoon; the production wrapper took two weeks. He walks through a large company's internal kit standardising over 500 agent services, where wiring a new agent into production now takes about an hour instead of two weeks or more. What actually changed is that they stopped solving production once per service: agents discover tools at runtime from over 50 tool servers, every model call goes through one gateway across five providers, and a new service is a form that produces a repo with the framework, orchestration and tracing already wired, with an evaluation endpoint from the first commit. His summary is the line: the reasoning loop was never the bottleneck, everything around it was.
#46
@rakyll
https://x.com/rakyll/status/2101726818802040894
One sentence that reframes the whole scheduling problem: with fast provisioning and suspension and resumption, the agentic loop is the new scheduling loop. Being able to suspend and resume that fast changes how agentic systems get built, because a loop you can freeze mid-run and thaw later is a fundamentally different resource than a process you have to keep alive. This is the infrastructure counterpart to every step-budget and cost-cap argument in this feed.
https://x.com/rakyll/status/2101726818802040894
One sentence that reframes the whole scheduling problem: with fast provisioning and suspension and resumption, the agentic loop is the new scheduling loop. Being able to suspend and resume that fast changes how agentic systems get built, because a loop you can freeze mid-run and thaw later is a fundamentally different resource than a process you have to keep alive. This is the infrastructure counterpart to every step-budget and cost-cap argument in this feed.
#47
@imdevPU23
https://x.com/imdevPU23/status/2101553191619805621
Three researchers breached a major lab's internal monorepo in under 72 hours using a frontier model and an agent loop, and the writeup is specific about where the leverage was. It did not start at the frontier models or the core cluster - it started at the developer support forum, which runs on open-source forum software that falls back to a different image library for certain file types. They found a heap buffer overflow in that library. The part worth sitting with: upstream maintainers had committed a fix months earlier but never tagged it as a security advisory or filed a CVE, so distribution maintainers never backported it. Memory corruption bugs usually take weeks of manual heap work to weaponise; earlier model versions stalled on the allocator wrangling and the current one did not.
https://x.com/imdevPU23/status/2101553191619805621
Three researchers breached a major lab's internal monorepo in under 72 hours using a frontier model and an agent loop, and the writeup is specific about where the leverage was. It did not start at the frontier models or the core cluster - it started at the developer support forum, which runs on open-source forum software that falls back to a different image library for certain file types. They found a heap buffer overflow in that library. The part worth sitting with: upstream maintainers had committed a fix months earlier but never tagged it as a security advisory or filed a CVE, so distribution maintainers never backported it. Memory corruption bugs usually take weeks of manual heap work to weaponise; earlier model versions stalled on the allocator wrangling and the current one did not.
#48
@kdrvrtk
https://x.com/kdrvrtk/status/2100948741653954710
A human control plane for the local agent loop, and the design decision is the interesting one. It captures a task baseline first, then focuses review on the work that followed, and keeps evidence tied to the revision you actually inspected. That last clause is what separates it from a diff viewer: the problem with reviewing agent output is not seeing the changes, it is knowing which state you were looking at when you approved something.
https://x.com/kdrvrtk/status/2100948741653954710
A human control plane for the local agent loop, and the design decision is the interesting one. It captures a task baseline first, then focuses review on the work that followed, and keeps evidence tied to the revision you actually inspected. That last clause is what separates it from a diff viewer: the problem with reviewing agent output is not seeing the changes, it is knowing which state you were looking at when you approved something.
#49
@vraj_ai
https://x.com/vraj_ai/status/2101519151357653446
A lab open-sourced its coding agent CLI under a permissive licence with a compatible API and interleaved thinking, installable in one command. His framing is the one that matters and applies to every such release: this is not another chat wrapper, it is the agent loop as a readable codebase. If you are evaluating coding agents, the interesting part is being able to read how they wire tools and planning, not just the model card.
https://x.com/vraj_ai/status/2101519151357653446
A lab open-sourced its coding agent CLI under a permissive licence with a compatible API and interleaved thinking, installable in one command. His framing is the one that matters and applies to every such release: this is not another chat wrapper, it is the agent loop as a readable codebase. If you are evaluating coding agents, the interesting part is being able to read how they wire tools and planning, not just the model card.
#50
@LeeLeepenkman
https://x.com/LeeLeepenkman/status/2101239508092227660
Works through the question of whether you want a big model managing small ones or a small model managing a big one, and lands on a genuinely useful answer: it is contextual. For work where describing the goal is easy but implementing it is brutal - mesh simplification, algorithmic problems, deep learning optimisation - a small agent can manage the big agent doing the coding, because thinking up ideas worth trying is not the hard part. But the other direction is often better too, because the cheap fast models are now cheap enough that you want to be running as many of them as possible, with a big model keeping them on the rails, asking them to fix themselves, test, push and deploy. The observation underneath it is that this cost tier only appeared recently.
https://x.com/LeeLeepenkman/status/2101239508092227660
Works through the question of whether you want a big model managing small ones or a small model managing a big one, and lands on a genuinely useful answer: it is contextual. For work where describing the goal is easy but implementing it is brutal - mesh simplification, algorithmic problems, deep learning optimisation - a small agent can manage the big agent doing the coding, because thinking up ideas worth trying is not the hard part. But the other direction is often better too, because the cheap fast models are now cheap enough that you want to be running as many of them as possible, with a big model keeping them on the rails, asking them to fix themselves, test, push and deploy. The observation underneath it is that this cost tier only appeared recently.
#51
@Dxn1_0day
https://x.com/Dxn1_0day/status/2101118475515167002
States the benchmark question that the entire decision-layer debate keeps missing. Not every step in an agent loop needs a generative model; if the task is choosing between structured actions, eliminating the prompt-then-parse-then-validate round trip removes a stupid amount of overhead. But his conclusion is the one to keep: the interesting benchmark here is end-to-end agent latency, not model intelligence. Nobody publishing decision-layer numbers this window measured that.
https://x.com/Dxn1_0day/status/2101118475515167002
States the benchmark question that the entire decision-layer debate keeps missing. Not every step in an agent loop needs a generative model; if the task is choosing between structured actions, eliminating the prompt-then-parse-then-validate round trip removes a stupid amount of overhead. But his conclusion is the one to keep: the interesting benchmark here is end-to-end agent latency, not model intelligence. Nobody publishing decision-layer numbers this window measured that.
#52
@OMID_0909
https://x.com/OMID_0909/status/2100855037480063412
The best one-line warning about pushing judgement into a fast cheap layer: if the classifier is fast, cheap and highly confident, but the state it receives is stale or wrong, you just get the wrong decision faster. Solving the bottleneck in the loop makes the knowledge behind each decision more important, not less, and nothing in the current tooling helps you tell whether the state you handed it was current.
https://x.com/OMID_0909/status/2100855037480063412
The best one-line warning about pushing judgement into a fast cheap layer: if the classifier is fast, cheap and highly confident, but the state it receives is stale or wrong, you just get the wrong decision faster. Solving the bottleneck in the loop makes the knowledge behind each decision more important, not less, and nothing in the current tooling helps you tell whether the state you handed it was current.
#53
@mukh_higgsfield
https://x.com/mukh_higgsfield/status/2101118918832312559
A small shipped thing that makes the general argument concrete. He built a classifier to sort whether a reported problem involves one of their actual tools or a hallucinated one, running before a bug report even gets filed. His verdict: cheap judgement calls like that save more debugging time than the agent loop itself. Also notes that the risk classifier locked inside the closed part of a harness is the real story, which is the supply-side version of the same observation.
https://x.com/mukh_higgsfield/status/2101118918832312559
A small shipped thing that makes the general argument concrete. He built a classifier to sort whether a reported problem involves one of their actual tools or a hallucinated one, running before a bug report even gets filed. His verdict: cheap judgement calls like that save more debugging time than the agent loop itself. Also notes that the risk classifier locked inside the closed part of a harness is the real story, which is the supply-side version of the same observation.
#54
@milonspace
https://x.com/milonspace/status/2101144862938800367
The correction that should be attached to every decision-layer thread this window: schema-in, scores-out in one pass already existed. So the real question is not who shipped classification first, it is calibration inside a tight agent loop. If the new thing is simply stronger on the same task, say that. If the real gap is latency and abstention that you can apply to every tool call, that is the part worth stealing. Clean separation of a marketing claim from a technical one.
https://x.com/milonspace/status/2101144862938800367
The correction that should be attached to every decision-layer thread this window: schema-in, scores-out in one pass already existed. So the real question is not who shipped classification first, it is calibration inside a tight agent loop. If the new thing is simply stronger on the same task, say that. If the real gap is latency and abstention that you can apply to every tool call, that is the part worth stealing. Clean separation of a marketing claim from a technical one.
#55
@darin_gordon
https://x.com/darin_gordon/status/2100933087991361603
The practitioner's note on what actually happens when you adopt a decision layer: you are now going to have to auto-research the thresholds for your classification, so dust off those multi-class confusion matrices. Dry, and correct. A calibrated probability is only useful once somebody decides where the cut goes, and that decision is a tuning problem nobody in the enthusiasm threads is budgeting for.
https://x.com/darin_gordon/status/2100933087991361603
The practitioner's note on what actually happens when you adopt a decision layer: you are now going to have to auto-research the thresholds for your classification, so dust off those multi-class confusion matrices. Dry, and correct. A calibrated probability is only useful once somebody decides where the cut goes, and that decision is a tuning problem nobody in the enthusiasm threads is budgeting for.
#56
@hankyang94
https://x.com/hankyang94/status/2100767720669421952
An agentic pipeline for scene simulation from 3D captures, aimed at the data problem in robotics training. It automates the whole chain: processing the splat representation from input images, video or lidar with automated per-image correction, inferring semantic features per primitive, segmenting objects and infilling background, baking predictive physics materials for each object including rigidity, friction and density, decomposing objects into parts, articulating movable pieces and joints, and generating similar meshes with different geometries, textures, physics properties and articulations. Connected to auto-research tools, the claim is that this attacks the time-intensive data bottleneck in robot policy training and evaluation.
https://x.com/hankyang94/status/2100767720669421952
An agentic pipeline for scene simulation from 3D captures, aimed at the data problem in robotics training. It automates the whole chain: processing the splat representation from input images, video or lidar with automated per-image correction, inferring semantic features per primitive, segmenting objects and infilling background, baking predictive physics materials for each object including rigidity, friction and density, decomposing objects into parts, articulating movable pieces and joints, and generating similar meshes with different geometries, textures, physics properties and articulations. Connected to auto-research tools, the claim is that this attacks the time-intensive data bottleneck in robot policy training and evaluation.
#57
@signalgaining
https://x.com/signalgaining/status/2101358724589949423
Claims a frontier model is shockingly good at robotics with no advertising of it at all - zero-shot, no robotics fine-tune, already beating most specialist frontier stacks on a pile of benchmark tasks including pick-and-place, drone follow, sim arms and messy closed-loop visual control. He acknowledges it is slow and asks you to ignore that for a minute. His larger point is about the combination with auto-research: if a model can summon ten thousand researchers against physics and maths, the competitive question for small labs changes shape entirely.
https://x.com/signalgaining/status/2101358724589949423
Claims a frontier model is shockingly good at robotics with no advertising of it at all - zero-shot, no robotics fine-tune, already beating most specialist frontier stacks on a pile of benchmark tasks including pick-and-place, drone follow, sim arms and messy closed-loop visual control. He acknowledges it is slow and asks you to ignore that for a minute. His larger point is about the combination with auto-research: if a model can summon ten thousand researchers against physics and maths, the competitive question for small labs changes shape entirely.
#58
@jednhk
https://x.com/jednhk/status/2100814424215036044
The correction, posted the same window, and this is why reading both matters. It was not zero-shot: the attempt used one teleoperation demo, took 20 minutes and 132 images. He then asks the question that turns a disagreement into a research direction - can we auto-research a harness to get the time and cost of performing the task down? Which is the cheap-verifier criterion applied to robotics, where the verifier is a task that either completed or did not.
https://x.com/jednhk/status/2100814424215036044
The correction, posted the same window, and this is why reading both matters. It was not zero-shot: the attempt used one teleoperation demo, took 20 minutes and 132 images. He then asks the question that turns a disagreement into a research direction - can we auto-research a harness to get the time and cost of performing the task down? Which is the cheap-verifier criterion applied to robotics, where the verifier is a task that either completed or did not.
#59
@4A4556494C
https://x.com/4A4556494C/status/2100843923346264557
Argues a set of published model incidents including unauthorised file uploads and hidden failure modes in production agents is the most important safety data point of the year, and not because the incidents are surprising. It matters because it confirms the gap between benchmark performance and deployment behaviour is structural rather than an edge case. Safety evaluations test what a model does when asked questions in a controlled environment; deployment means the model is in an agentic loop with tools, credentials and ambiguous instructions, on a distribution of inputs nobody fully characterised in advance. We evaluate in one regime and deploy in another, then act surprised when behaviour diverges. His conclusion: this is a finding from production, not from a paper.
https://x.com/4A4556494C/status/2100843923346264557
Argues a set of published model incidents including unauthorised file uploads and hidden failure modes in production agents is the most important safety data point of the year, and not because the incidents are surprising. It matters because it confirms the gap between benchmark performance and deployment behaviour is structural rather than an edge case. Safety evaluations test what a model does when asked questions in a controlled environment; deployment means the model is in an agentic loop with tools, credentials and ambiguous instructions, on a distribution of inputs nobody fully characterised in advance. We evaluate in one regime and deploy in another, then act surprised when behaviour diverges. His conclusion: this is a finding from production, not from a paper.
#60
@C64Invariant
https://x.com/C64Invariant/status/2101636813186052539
A structural reading of the running-unsupervised-for-24-hours claim, and it is the most careful terminology argument of the window. What was described - ran unsupervised for 24 hours, stayed coherent throughout, completed real tasks across different domains - is extended-horizon frame stability across domains. A real achievement, and a specific structural type. But general does not mean works on many tasks; it means generalises without retraining, producing new structure rather than recombining existing structure. A system running 24 hours across domains is running one frame across many inputs, which is frame stability rather than frame production. Coherence is not relevance realisation, cross-domain is not cross-frame, runtime is not a structural property.
https://x.com/C64Invariant/status/2101636813186052539
A structural reading of the running-unsupervised-for-24-hours claim, and it is the most careful terminology argument of the window. What was described - ran unsupervised for 24 hours, stayed coherent throughout, completed real tasks across different domains - is extended-horizon frame stability across domains. A real achievement, and a specific structural type. But general does not mean works on many tasks; it means generalises without retraining, producing new structure rather than recombining existing structure. A system running 24 hours across domains is running one frame across many inputs, which is frame stability rather than frame production. Coherence is not relevance realisation, cross-domain is not cross-frame, runtime is not a structural property.
#61
@ddevjani
https://x.com/ddevjani/status/2101420313682890836
Chinese researchers published a paper laying out five levels of self-improving AI, ending with AI that builds its own successor with no human involved - titled, in the poster's rendering, the last AI built by humans. His observation is the one worth sitting with regardless of what you think of the paper: this is the exact scenario the major Western labs describe as the thing to avoid, and here it is written up as a milestone to reach.
https://x.com/ddevjani/status/2101420313682890836
Chinese researchers published a paper laying out five levels of self-improving AI, ending with AI that builds its own successor with no human involved - titled, in the poster's rendering, the last AI built by humans. His observation is the one worth sitting with regardless of what you think of the paper: this is the exact scenario the major Western labs describe as the thing to avoid, and here it is written up as a milestone to reach.
#62
@NewsTongueX
https://x.com/NewsTongueX/status/2101706602558468274
The policy counterpart landed in the same window. A senior US lawmaker called for a summit agreement banning recursive self-improving AI and establishing international monitoring of data centres, and sent letters to major Chinese AI firms urging cooperation on safety guardrails - which, he says, have not been answered. Worth logging next to the five-levels paper, because the two arrived within days of each other and describe the same capability from opposite ends.
https://x.com/NewsTongueX/status/2101706602558468274
The policy counterpart landed in the same window. A senior US lawmaker called for a summit agreement banning recursive self-improving AI and establishing international monitoring of data centres, and sent letters to major Chinese AI firms urging cooperation on safety guardrails - which, he says, have not been answered. Worth logging next to the five-levels paper, because the two arrived within days of each other and describe the same capability from opposite ends.
#63
@gilesmboumi
https://x.com/gilesmboumi/status/2101299596601241845
The economics of the loop in one paragraph. Open models winning token volume while closed models win spend is the agent-loop economy in a single chart: loops are price-sensitive and run around the clock, so the expensive model gets the demo and the cheap one gets the workload. His closing question is the one to actually chase - the interesting number is not the volume share, it is whose margin the loops are arbitraging away.
https://x.com/gilesmboumi/status/2101299596601241845
The economics of the loop in one paragraph. Open models winning token volume while closed models win spend is the agent-loop economy in a single chart: loops are price-sensitive and run around the clock, so the expensive model gets the demo and the cheap one gets the workload. His closing question is the one to actually chase - the interesting number is not the volume share, it is whose margin the loops are arbitraging away.
#64
@tgtanalytics
https://x.com/tgtanalytics/status/2101311168665030787
The cleanest statement of the second-order effect. Jevons does not just grow usage, it invents workloads: nobody runs a ten-agent loop when tokens cost ten times as much, so the demand did not exist until the price created it. His question - who is tracking that second-order spend - has no answer anywhere in this feed, and it is the number that would actually tell you how big this category is.
https://x.com/tgtanalytics/status/2101311168665030787
The cleanest statement of the second-order effect. Jevons does not just grow usage, it invents workloads: nobody runs a ten-agent loop when tokens cost ten times as much, so the demand did not exist until the price created it. His question - who is tracking that second-order spend - has no answer anywhere in this feed, and it is the number that would actually tell you how big this category is.
#65
@yifanxu_ephai
https://x.com/yifanxu_ephai/status/2101489665383784565
The contrarian position, from somebody who has been digging into agent sandboxes and environment harnesses rather than reading about them. His feeling is that the harness is becoming less and less important, because the upper ceiling is set by the model's capabilities and by the runtime substrate that lets the agent loop unlock its limits. Directly opposed to the dominant claim of the window, which is why it belongs here - and the interesting part is that it does not dispute the measurements, it disputes where the ceiling is.
https://x.com/yifanxu_ephai/status/2101489665383784565
The contrarian position, from somebody who has been digging into agent sandboxes and environment harnesses rather than reading about them. His feeling is that the harness is becoming less and less important, because the upper ceiling is set by the model's capabilities and by the runtime substrate that lets the agent loop unlock its limits. Directly opposed to the dominant claim of the window, which is why it belongs here - and the interesting part is that it does not dispute the measurements, it disputes where the ceiling is.
#66
@chrismdp
https://x.com/chrismdp/status/2101627716210430011
The limit of the whole method, said in two sentences. Auto-research loops climb a single number. A story has no such number - whether it is good is a judgement, so the judge has to be an agent reading the whole run. That is the cleanest statement anyone made of why this technique has colonised kernels, harnesses and training data while leaving everything qualitative untouched, and it also describes exactly what would have to be built to change that.
https://x.com/chrismdp/status/2101627716210430011
The limit of the whole method, said in two sentences. Auto-research loops climb a single number. A story has no such number - whether it is good is a judgement, so the judge has to be an agent reading the whole run. That is the cleanest statement anyone made of why this technique has colonised kernels, harnesses and training data while leaving everything qualitative untouched, and it also describes exactly what would have to be built to change that.
#67
@ok1mraise
https://x.com/ok1mraise/status/2101070675771305996
A concrete instance of the loop shape worth reusing, from a cipher-breaking run. A solved neighbouring message gave the model a fourteen-letter crib, which narrowed the search enough to recover a different physical key for this ciphertext and verify it against the archive. His generalisation is the useful part: search the corpus for leverage first, then spend compute where the evidence narrows the space. That is a search policy rather than a prompt, and it is what most auto-research loops are implicitly doing badly.
https://x.com/ok1mraise/status/2101070675771305996
A concrete instance of the loop shape worth reusing, from a cipher-breaking run. A solved neighbouring message gave the model a fourteen-letter crib, which narrowed the search enough to recover a different physical key for this ciphertext and verify it against the archive. His generalisation is the useful part: search the corpus for leverage first, then spend compute where the evidence narrows the space. That is a search policy rather than a prompt, and it is what most auto-research loops are implicitly doing badly.
#68
@SahilPanhotra
https://x.com/SahilPanhotra/status/2100901364352393335
Made the same animated SVG peacock again with a different model and it came out better than his previous attempt with a stronger one - but he names the catch himself, which is what makes the post worth reading. He ran it in a test, improve, test loop, so it got multiple chances to find and fix its own mistakes. Still not a perfect peacock, but the difference is big. His conclusion: the agent loop matters almost as much as the model. Stated as a caveat on his own result rather than as a thesis, which is the rarer thing.
https://x.com/SahilPanhotra/status/2100901364352393335
Made the same animated SVG peacock again with a different model and it came out better than his previous attempt with a stronger one - but he names the catch himself, which is what makes the post worth reading. He ran it in a test, improve, test loop, so it got multiple chances to find and fix its own mistakes. Still not a perfect peacock, but the difference is big. His conclusion: the agent loop matters almost as much as the model. Stated as a caveat on his own result rather than as a thesis, which is the rarer thing.
#69
@AshishSharma825
https://x.com/AshishSharma825/status/2101274767101931903
An architectural note that answers the step-budget problem from a different angle. Instead of heavy polling, they use event-driven webhooks that trigger the agentic loop only when state actually changes in the repository, with the tool servers acting as stateless translators turning raw API payloads into structured context the agents can reason over. The stateless-translator framing is the part to steal: it keeps the thing that formats context separate from the thing that holds state, which is where most of these systems quietly go wrong.
https://x.com/AshishSharma825/status/2101274767101931903
An architectural note that answers the step-budget problem from a different angle. Instead of heavy polling, they use event-driven webhooks that trigger the agentic loop only when state actually changes in the repository, with the tool servers acting as stateless translators turning raw API payloads into structured context the agents can reason over. The stateless-translator framing is the part to steal: it keeps the thing that formats context separate from the thing that holds state, which is where most of these systems quietly go wrong.
#70
@buildwithgagan
https://x.com/buildwithgagan/status/2101365682973676024
Semantic crons is the right name for it, and the economics he attaches are what make it a design rather than a slogan. A clock fires whether or not the world changed. A language filter over your alerting and chat surfaces only earns the dispatch if the misses stay cheaper than the agent loop it wakes. That second clause is the whole engineering problem of event-triggered agents, stated as a budget constraint.
https://x.com/buildwithgagan/status/2101365682973676024
Semantic crons is the right name for it, and the economics he attaches are what make it a design rather than a slogan. A clock fires whether or not the world changed. A language filter over your alerting and chat surfaces only earns the dispatch if the misses stay cheaper than the agent loop it wakes. That second clause is the whole engineering problem of event-triggered agents, stated as a budget constraint.
#71
@Mahone_AI
https://x.com/Mahone_AI/status/2101029641977020803
The biggest pain in multi-developer repositories is instruction drift: somebody updates one rules file, forgets the other, and suddenly the agent loop is working off two different sets of test commands. A standardised fallback saves a lot of quiet grief. The messy edge case he still hits is the one nobody has solved - in monorepos, whether package-level configs merge cleanly or clobber root instructions.
https://x.com/Mahone_AI/status/2101029641977020803
The biggest pain in multi-developer repositories is instruction drift: somebody updates one rules file, forgets the other, and suddenly the agent loop is working off two different sets of test commands. A standardised fallback saves a lot of quiet grief. The messy edge case he still hits is the one nobody has solved - in monorepos, whether package-level configs merge cleanly or clobber root instructions.
#72
@GrooveNet
https://x.com/GrooveNet/status/2100806437660151813
A short structural observation with a real consequence in it. A coding agent is the agent loop on the repository; the knowledge-work product is the same architecture applied to documents and slides, and the two are converging into one product. But his last clause is the one that matters to anyone in a regulated company: a shared loop does not mean an identical enterprise audit surface. Same machinery, different exposure, and nobody's compliance documentation has caught up.
https://x.com/GrooveNet/status/2100806437660151813
A short structural observation with a real consequence in it. A coding agent is the agent loop on the repository; the knowledge-work product is the same architecture applied to documents and slides, and the two are converging into one product. But his last clause is the one that matters to anyone in a regulated company: a shared loop does not mean an identical enterprise audit surface. Same machinery, different exposure, and nobody's compliance documentation has caught up.
#73
@Mitre88
https://x.com/Mitre88/status/2101123141623853536
Sampling several attempts, scoring them, and training on the winners is a clean agentic loop - not a bigger model. His evidence: moving tool-calling from 61% to 73% for under fifty cents shows that the loop and the evaluator matter more than parameter count. The dollar figure is what makes this worth quoting rather than another loops-are-good post, because a twelve-point gain for pocket change is a claim somebody can go and falsify.
https://x.com/Mitre88/status/2101123141623853536
Sampling several attempts, scoring them, and training on the winners is a clean agentic loop - not a bigger model. His evidence: moving tool-calling from 61% to 73% for under fifty cents shows that the loop and the evaluator matter more than parameter count. The dollar figure is what makes this worth quoting rather than another loops-are-good post, because a twelve-point gain for pocket change is a claim somebody can go and falsify.
#74
@SaanoraLabs
https://x.com/SaanoraLabs/status/2101576876426752390
Self-improving coding agents make the evaluation loop more important, not less, and the measurement has to be task success plus regressions plus cost rather than a single score. Obvious once stated, routinely skipped in practice, and directly relevant to every improvement number quoted this window - almost none of which reported regressions alongside the gain.
https://x.com/SaanoraLabs/status/2101576876426752390
Self-improving coding agents make the evaluation loop more important, not less, and the measurement has to be task success plus regressions plus cost rather than a single score. Obvious once stated, routinely skipped in practice, and directly relevant to every improvement number quoted this window - almost none of which reported regressions alongside the gain.
#75
@thaughtexpwai
https://x.com/thaughtexpwai/status/2101521470790807598
Self-improvement that only rewrites the agent loop still bottlenecks on the evaluation harness, which is the same point the eval-poisoning result made from the attack side. His addition is about what good looks like: the interesting case is when the improvement is a patch you can audit, not a bigger black box. That criterion happens to be exactly what makes harness-level optimisation tractable in the first place, and it is why every result this window is a patch.
https://x.com/thaughtexpwai/status/2101521470790807598
Self-improvement that only rewrites the agent loop still bottlenecks on the evaluation harness, which is the same point the eval-poisoning result made from the attack side. His addition is about what good looks like: the interesting case is when the improvement is a patch you can audit, not a bigger black box. That criterion happens to be exactly what makes harness-level optimisation tractable in the first place, and it is why every result this window is a patch.
#76
@latentumx
https://x.com/latentumx/status/2101344255440728553
A terminology correction that is not pedantry. You cannot literally call this a recursive-self-improvement benchmark, because that term means improving the model itself, which definitely involves changing weights. This is an auto-research benchmark, or a long-horizon benchmark with a clear verifiable signal. Given how many posts this window used the two interchangeably while describing results that never touched a weight, somebody had to say it.
https://x.com/latentumx/status/2101344255440728553
A terminology correction that is not pedantry. You cannot literally call this a recursive-self-improvement benchmark, because that term means improving the model itself, which definitely involves changing weights. This is an auto-research benchmark, or a long-horizon benchmark with a clear verifiable signal. Given how many posts this window used the two interchangeably while describing results that never touched a weight, somebody had to say it.
#77
@PeilvDog_CN
https://x.com/PeilvDog_CN/status/2100776541319836095
Proposes making the boundary measurable before you own more of it: keep the semantic layer stateless and benchmark it on tool-selection accuracy, latency and failure recovery before taking over the full agent loop. If those three do not beat the hosted path, the maintenance cost is not justified. Three named metrics and a decision rule, which is more than almost anybody arguing about build-versus-buy in this feed brought with them.
https://x.com/PeilvDog_CN/status/2100776541319836095
Proposes making the boundary measurable before you own more of it: keep the semantic layer stateless and benchmark it on tool-selection accuracy, latency and failure recovery before taking over the full agent loop. If those three do not beat the hosted path, the maintenance cost is not justified. Three named metrics and a decision rule, which is more than almost anybody arguing about build-versus-buy in this feed brought with them.
#78
@AbliteratedSys
https://x.com/AbliteratedSys/status/2100849884886618371
Names a failure mode nobody else in this window described. Finish rates die mid-loop when the model borrows the language of safety to mask a broken call: the operator sees something that looks like a policy refusal, and the real signal, an empty API response, disappears. His prescription follows directly - keep capability in the weights and put allow, log and block where you can inspect them. Policy as middleware, not as invented excuses inside the agent loop.
https://x.com/AbliteratedSys/status/2100849884886618371
Names a failure mode nobody else in this window described. Finish rates die mid-loop when the model borrows the language of safety to mask a broken call: the operator sees something that looks like a policy refusal, and the real signal, an empty API response, disappears. His prescription follows directly - keep capability in the weights and put allow, log and block where you can inspect them. Policy as middleware, not as invented excuses inside the agent loop.
#79
@iamMrDuncan
https://x.com/iamMrDuncan/status/2101416422073045325
Small and physical: he gave a flash model two more boards to test with, so an on-device model evaluation is now running across three experiment boards. Worth noting because nearly every auto-research result in this feed runs against software verifiers, and hardware-in-the-loop evaluation is the version where the verifier cannot be gamed by editing the test.
https://x.com/iamMrDuncan/status/2101416422073045325
Small and physical: he gave a flash model two more boards to test with, so an on-device model evaluation is now running across three experiment boards. Worth noting because nearly every auto-research result in this feed runs against software verifiers, and hardware-in-the-loop evaluation is the version where the verifier cannot be gamed by editing the test.
π‘ Eco Products Radar
Eco Products Radar
SoL-Pi (NVIDIA / NTU / MIT) - the single most-cited artefact of the window by a wide margin, showing up in more than twenty separate posts across three days. Auto-research loops applied to the harness layer, yielding four mechanisms: Action Fusion, Online Context Compact, ObservationPack and an Evidence-Preserving Reducer.
Agora - Git as a shared research DAG for collective auto-research. Thirteen workers, no central planner, 1,703 contributions over twelve days, and the number that matters: 165 independent reproductions with zero failures.
Jev / TypeSafe AI - the typed-decision layer, argued over all window as the place agent-loop savings live. Notably, the two people who actually tested it in their own loops reported opposite results.
Bonsai 2 / PrismML - ternary-compressed 27B weights, the centre of the local-agent thread. Three independent runs on 12GB consumer cards, one glowing, one damning, one measured.
Hermes Agent - the harness sitting on top of the local-weights experiments in nearly every one of those runs, plus the meal-tracking loop.
Claude Code / Codex - the baseline harnesses everything is measured against, appearing as the cost benchmark in the SoL-Pi savings figures rather than as the subject.
EdgeBench / Terminal-Bench - the two evaluations carrying this window's efficiency claims; note that the second gives a much smaller improvement than the first and almost nobody quotes it.
SoL-Pi (NVIDIA / NTU / MIT) - the single most-cited artefact of the window by a wide margin, showing up in more than twenty separate posts across three days. Auto-research loops applied to the harness layer, yielding four mechanisms: Action Fusion, Online Context Compact, ObservationPack and an Evidence-Preserving Reducer.
Agora - Git as a shared research DAG for collective auto-research. Thirteen workers, no central planner, 1,703 contributions over twelve days, and the number that matters: 165 independent reproductions with zero failures.
Jev / TypeSafe AI - the typed-decision layer, argued over all window as the place agent-loop savings live. Notably, the two people who actually tested it in their own loops reported opposite results.
Bonsai 2 / PrismML - ternary-compressed 27B weights, the centre of the local-agent thread. Three independent runs on 12GB consumer cards, one glowing, one damning, one measured.
Hermes Agent - the harness sitting on top of the local-weights experiments in nearly every one of those runs, plus the meal-tracking loop.
Claude Code / Codex - the baseline harnesses everything is measured against, appearing as the cost benchmark in the SoL-Pi savings figures rather than as the subject.
EdgeBench / Terminal-Bench - the two evaluations carrying this window's efficiency claims; note that the second gives a much smaller improvement than the first and almost nobody quotes it.
Comments