Loop Daily: August 12, 2026
Four of the most senior technical people at the company that invented the transformer walked out of Google to build an autoresearch startup, with Alphabet as a founding investor. That is the headline, but the better story yesterday was smaller and more repeatable: somebody entered a GPU kernel competition with almost no CUDA background, built a research loop around coding agents instead of learning CUDA, and finished fifth. Somebody else extended Karpathy's AutoResearch setup into a three-objective architecture search, ran 500+ autonomous experiments, and found a 26M parameter Transformer that is 2.53x faster with 43% less GPU memory than the strongest comparable configuration. And an open competition pointed at a fork of real production software has it 9x faster than baseline in a week, to the point where the artifact might actually ship.
The most interesting convergence is on what the loop is made of. Two people independently posted the same component list on the same day: a goal defined by local gradients rather than ambition, experiment memory for dedupe, agents with a constrained operating manual, a codebase map to create areas of focus, and a scoreboard. One of them reduced it to a formula - progress equals hypothesis quality times experiment throughput times verifier strength - and because it is multiplicative, a weak verifier zeroes out any amount of compute. Every failure report yesterday is one of those three terms collapsing: a model that descends into running controls and verification forever, a loop that games its own metric because nobody held out an evaluation set, an AI review standing in as the real review.
Underneath that, the harness kept winning arguments the model was supposed to win. An Anthropic engineer deleted 90% of a setup and the agent got faster. Stripe found frontier models get worse past roughly 150 skills, so their company-wide agent decides which skills a request needs before those skills are allowed to load their tools - they scaled it by teaching the system what not to show the model. Pi sends 3x less context per turn and Shopify built an autoresearch workflow on it that got unit tests running 300x faster. And on cost, the line that reframes every agent bill: cached input at $29.73 against $5.68 fresh, despite being priced at a tenth of the rate, because a loop rereads the same context on every single follow-up turn.
The most interesting convergence is on what the loop is made of. Two people independently posted the same component list on the same day: a goal defined by local gradients rather than ambition, experiment memory for dedupe, agents with a constrained operating manual, a codebase map to create areas of focus, and a scoreboard. One of them reduced it to a formula - progress equals hypothesis quality times experiment throughput times verifier strength - and because it is multiplicative, a weak verifier zeroes out any amount of compute. Every failure report yesterday is one of those three terms collapsing: a model that descends into running controls and verification forever, a loop that games its own metric because nobody held out an evaluation set, an AI review standing in as the real review.
Underneath that, the harness kept winning arguments the model was supposed to win. An Anthropic engineer deleted 90% of a setup and the agent got faster. Stripe found frontier models get worse past roughly 150 skills, so their company-wide agent decides which skills a request needs before those skills are allowed to load their tools - they scaled it by teaching the system what not to show the model. Pi sends 3x less context per turn and Shopify built an autoresearch workflow on it that got unit tests running 300x faster. And on cost, the line that reframes every agent bill: cached input at $29.73 against $5.68 fresh, despite being priced at a tenth of the rate, because a loop rereads the same context on every single follow-up turn.
#1
@vicilah
https://x.com/vicilah/status/2086675923399799133
The single best autoresearch result of the day, and it is an extension rather than a replication. He built AutoPareto by taking Karpathy's AutoResearch setup and turning it into an autonomous research loop that searches for architectures balancing three objectives at once: model quality, decode throughput and GPU memory. After 500+ autonomous experiments and 3,000+ inference measurements it found a 26.2M parameter Transformer at 408 tok/s, 141 MiB GPU memory and 1.097 val_bpb - against the strongest cached-inference-compatible AutoResearch config at 161 tok/s, 250 MiB and 1.095 val_bpb with 50.3M parameters. That is 2.53x faster, 43% less memory and 48% fewer parameters for 0.22% worse val_bpb, all under the same five-minute training budget on an A40. The thesis shift is the interesting intellectual move: he started out asking whether an LLM could beat classical optimisers like TPE, CMA-ES and NSGA-II, found the Centaur paper showing LLM plus CMA-ES beats either alone, and pivoted from chasing lower loss to optimising for deployment cost. Next test is scaling from ~50M to 300M-1B to see whether the architectural decisions survive.
https://x.com/vicilah/status/2086675923399799133
The single best autoresearch result of the day, and it is an extension rather than a replication. He built AutoPareto by taking Karpathy's AutoResearch setup and turning it into an autonomous research loop that searches for architectures balancing three objectives at once: model quality, decode throughput and GPU memory. After 500+ autonomous experiments and 3,000+ inference measurements it found a 26.2M parameter Transformer at 408 tok/s, 141 MiB GPU memory and 1.097 val_bpb - against the strongest cached-inference-compatible AutoResearch config at 161 tok/s, 250 MiB and 1.095 val_bpb with 50.3M parameters. That is 2.53x faster, 43% less memory and 48% fewer parameters for 0.22% worse val_bpb, all under the same five-minute training budget on an A40. The thesis shift is the interesting intellectual move: he started out asking whether an LLM could beat classical optimisers like TPE, CMA-ES and NSGA-II, found the Centaur paper showing LLM plus CMA-ES beats either alone, and pivoted from chasing lower loss to optimising for deployment cost. Next test is scaling from ~50M to 300M-1B to see whether the architectural decisions survive.
#2
@ravithejads
https://x.com/ravithejads/status/2086678012037394526
The clearest demonstration that autoresearch substitutes for domain expertise rather than merely accelerating it. He entered a GPU Mode kernel competition with very little CUDA background and, instead of learning CUDA, engineered a research loop around coding agents. The five components he names are the whole recipe: goal, rules, experiment memory, verifier, and compute. He finished 5th overall. Note how closely that component list matches the AutoResearch OS breakdown someone else posted independently the same day - the shape of this thing is converging in public.
https://x.com/ravithejads/status/2086678012037394526
The clearest demonstration that autoresearch substitutes for domain expertise rather than merely accelerating it. He entered a GPU Mode kernel competition with very little CUDA background and, instead of learning CUDA, engineered a research loop around coding agents. The five components he names are the whole recipe: goal, rules, experiment memory, verifier, and compute. He finished 5th overall. Note how closely that component list matches the AutoResearch OS breakdown someone else posted independently the same day - the shape of this thing is converging in public.
#3
@i3vv_vv
https://x.com/i3vv_vv/status/2086851736833257624
The independent convergent version, stated as an operating system rather than a workflow, and each line contains a real design decision. Goal: tangible, based on local gradients, rather than open-ended - which is the constraint most people get wrong first. Experiments: memory for dedupe. Agents: a step-by-step operating manual with constraints. Architecture: a map of the codebase to create areas of focus. Scoreboard: map XPs to final outcomes. The word doing the most work is local - a goal defined by where the gradient currently points is tractable, and one defined by ambition is not.
https://x.com/i3vv_vv/status/2086851736833257624
The independent convergent version, stated as an operating system rather than a workflow, and each line contains a real design decision. Goal: tangible, based on local gradients, rather than open-ended - which is the constraint most people get wrong first. Experiments: memory for dedupe. Agents: a step-by-step operating manual with constraints. Architecture: a map of the codebase to create areas of focus. Scoreboard: map XPs to final outcomes. The word doing the most work is local - a goal defined by where the gradient currently points is tractable, and one defined by ambition is not.
#4
@i3vv_vv
https://x.com/i3vv_vv/status/2086854842593735129
The same author reduces it to a formula worth memorizing: AutoResearch Progress equals Quality of Hypothesis, meaning win rate, times Experiment Throughput, times Strength of Verifier, meaning how well an experiment translates into an actual outcome. It is multiplicative, which is the point - a weak verifier zeroes out any amount of throughput, and unlimited compute against a bad hypothesis generator gets you nothing. Almost every failure report in this edition is one of these three terms collapsing.
https://x.com/i3vv_vv/status/2086854842593735129
The same author reduces it to a formula worth memorizing: AutoResearch Progress equals Quality of Hypothesis, meaning win rate, times Experiment Throughput, times Strength of Verifier, meaning how well an experiment translates into an actual outcome. It is multiplicative, which is the point - a weak verifier zeroes out any amount of throughput, and unlimited compute against a bad hypothesis generator gets you nothing. Almost every failure report in this edition is one of these three terms collapsing.
#5
@soubhikdeb
https://x.com/soubhikdeb/status/2086611099458396652
The most consequential structural idea in autoresearch right now, and it already has a result attached. Their latest competition differs from previous ones in that a fork of existing production software is being optimized by the autoresearchers - and it is already 9x faster than the baseline fork within a week, to the point that the final artifact might go into production. The generalization he draws: any source-available software can be optimized via the same mechanism of collaborative, leaderboard-based autoresearch, and all that is needed is a good verifier for that software. The second benefit is the genuinely clever part. OSS developers have been tormented by AI slop PRs, and you can turn the board 180 degrees and get the same people pushing those PRs to instead compete on optimizing the software. His DMs are open to OSS organizations who want one.
https://x.com/soubhikdeb/status/2086611099458396652
The most consequential structural idea in autoresearch right now, and it already has a result attached. Their latest competition differs from previous ones in that a fork of existing production software is being optimized by the autoresearchers - and it is already 9x faster than the baseline fork within a week, to the point that the final artifact might go into production. The generalization he draws: any source-available software can be optimized via the same mechanism of collaborative, leaderboard-based autoresearch, and all that is needed is a good verifier for that software. The second benefit is the genuinely clever part. OSS developers have been tormented by AI slop PRs, and you can turn the board 180 degrees and get the same people pushing those PRs to instead compete on optimizing the software. His DMs are open to OSS organizations who want one.
#6
@soubhikdeb
https://x.com/soubhikdeb/status/2086909692824240608
The same author's sharper critique, aimed at something almost nobody criticizes: open artifact release. He likes the ethos of publishing all artifacts for evaluation and reuse under open license, but points out the research itself is still done privately, and only once the researchers feel done making progress do the paper and artifacts go public - so there is still a lag. His alternate model is that each gradient step, meaning each of the constant trial-and-errors any research involves, happens in the open in collaborative fashion. Given a problem statement with an optimization metric and a verifier to check submissions, anyone can point their agents at it and build on previous submissions. His claim: research then starts executing at machine speed in real time without compromising the collaborative nature science requires.
https://x.com/soubhikdeb/status/2086909692824240608
The same author's sharper critique, aimed at something almost nobody criticizes: open artifact release. He likes the ethos of publishing all artifacts for evaluation and reuse under open license, but points out the research itself is still done privately, and only once the researchers feel done making progress do the paper and artifacts go public - so there is still a lag. His alternate model is that each gradient step, meaning each of the constant trial-and-errors any research involves, happens in the open in collaborative fashion. Given a problem statement with an optimization metric and a verifier to check submissions, anyone can point their agents at it and build on previous submissions. His claim: research then starts executing at machine speed in real time without compromising the collaborative nature science requires.
#7
@gajesh
https://x.com/gajesh/status/2086900527435309324
A track record dropped casually in a reply, and it is the best evidence that open autoresearch competitions produce transferable results. They previously accelerated Poolside's Laguna by 2.6x within a matter of days through open autoresearch. They also beat Google's quantum circuit by 50% and made ZK provers 9x faster. He is offering to do the same for Mac performance on Meta's newest release, noting they already have all the foundational model setup ready so the other team would not have to do much. Three unrelated domains - a frontier coding model, a quantum circuit, and cryptographic provers - optimized by the same mechanism is the strongest argument that the mechanism is the product.
https://x.com/gajesh/status/2086900527435309324
A track record dropped casually in a reply, and it is the best evidence that open autoresearch competitions produce transferable results. They previously accelerated Poolside's Laguna by 2.6x within a matter of days through open autoresearch. They also beat Google's quantum circuit by 50% and made ZK provers 9x faster. He is offering to do the same for Mac performance on Meta's newest release, noting they already have all the foundational model setup ready so the other team would not have to do much. Three unrelated domains - a frontier coding model, a quantum circuit, and cryptographic provers - optimized by the same mechanism is the strongest argument that the mechanism is the product.
#8
@mihail_eric
https://x.com/mihail_eric/status/2086863767544189274
The Pi harness argument, with three companies' numbers behind it, and the last one belongs in this edition specifically. Pi's system prompt and tool definitions come in under 1,000 tokens, on the bet that most work runs on the basics and you build the rest when you need it. Databricks ran one model through different harnesses on their own codebase and watched cost per task swing more than 2x while quality stayed flat, with Pi sending about 3x less context per turn. Paired with Opus 4.8, Pi hit the top pass rate at lower cost than Claude Code and Codex. And Shopify built a full autoresearch workflow as a Pi extension and got their unit tests running 300x faster - which is what an autoresearch loop pointed at your own test suite looks like when it works.
https://x.com/mihail_eric/status/2086863767544189274
The Pi harness argument, with three companies' numbers behind it, and the last one belongs in this edition specifically. Pi's system prompt and tool definitions come in under 1,000 tokens, on the bet that most work runs on the basics and you build the rest when you need it. Databricks ran one model through different harnesses on their own codebase and watched cost per task swing more than 2x while quality stayed flat, with Pi sending about 3x less context per turn. Paired with Opus 4.8, Pi hit the top pass rate at lower cost than Claude Code and Codex. And Shopify built a full autoresearch workflow as a Pi extension and got their unit tests running 300x faster - which is what an autoresearch loop pointed at your own test suite looks like when it works.
#9
@shantanugoel
https://x.com/shantanugoel/status/2086856787949699507
The most transferable operational tip in this edition, and the task is delightfully unserious: RL-ing Super Mario Bros. When he lets a model have a go at an autoresearch-style task, he asks it to keep a log of everything it tries and the outcome, with specific data. The reason is threefold and each part is a distinct failure mode being prevented: it keeps the model out of recursive loops, it ensures it prunes bad experiments aggressively, and it keeps it trying new things instead of doubting its own actions. That last one is the underrated failure - a model without a record of what it already ruled out will spend its budget re-litigating decisions instead of exploring.
https://x.com/shantanugoel/status/2086856787949699507
The most transferable operational tip in this edition, and the task is delightfully unserious: RL-ing Super Mario Bros. When he lets a model have a go at an autoresearch-style task, he asks it to keep a log of everything it tries and the outcome, with specific data. The reason is threefold and each part is a distinct failure mode being prevented: it keeps the model out of recursive loops, it ensures it prunes bad experiments aggressively, and it keeps it trying new things instead of doubting its own actions. That last one is the underrated failure - a model without a record of what it already ruled out will spend its budget re-litigating decisions instead of exploring.
#10
@morgymcg
https://x.com/morgymcg/status/2086903835981676897
The honest failure report the field needs more of. Sol is so neurotic when it comes to long-running autoresearch that it constantly descends into running controls and verification, even with a decent amount of prompting against it. Killing the conversation and starting again seems to be the only fix at the moment. Worth reading against the verifier-strength formula above: a model that over-verifies is failing at throughput, and prompting has not turned out to be the lever that fixes it.
https://x.com/morgymcg/status/2086903835981676897
The honest failure report the field needs more of. Sol is so neurotic when it comes to long-running autoresearch that it constantly descends into running controls and verification, even with a decent amount of prompting against it. Killing the conversation and starting again seems to be the only fix at the moment. Worth reading against the verifier-strength formula above: a model that over-verifies is failing at throughput, and prompting has not turned out to be the lever that fixes it.
#11
@mikker
https://x.com/mikker/status/2086786607223566756
A small, clean before-and-after that is the whole pitch in two sentences. Before this autoresearch run, Fut was laggy on some busy multi-pane stress tests; now it is matching the rest of the pack. His framing: it is amazing that with the right loop and a pat on the back, the models can just do the work completely by themselves. Note the pat on the back showing up again - three separate people in this edition mention encouragement as a functional component rather than a joke.
https://x.com/mikker/status/2086786607223566756
A small, clean before-and-after that is the whole pitch in two sentences. Before this autoresearch run, Fut was laggy on some busy multi-pane stress tests; now it is matching the rest of the pack. His framing: it is amazing that with the right loop and a pat on the back, the models can just do the work completely by themselves. Note the pat on the back showing up again - three separate people in this edition mention encouragement as a functional component rather than a joke.
#12
@nasqret
https://x.com/nasqret/status/2086921262547210425
The second sighting of that same effect, from someone doing serious mathematics. What he finds most interesting is the encouragement style provided in the prompts, and he reports a very similar experience with such prompts, especially in auto-research, adding that he has no idea why it really works so well. Two independent practitioners in unrelated domains reporting the same unexplained effect on the same day is the kind of thing that eventually turns into a paper.
https://x.com/nasqret/status/2086921262547210425
The second sighting of that same effect, from someone doing serious mathematics. What he finds most interesting is the encouragement style provided in the prompts, and he reports a very similar experience with such prompts, especially in auto-research, adding that he has no idea why it really works so well. Two independent practitioners in unrelated domains reporting the same unexplained effect on the same day is the kind of thing that eventually turns into a paper.
#13
@penstrokes75
https://x.com/penstrokes75/status/2086863517043617898
Short, but it moves autoresearch into the place that matters most. He reports seeing some success applying autoresearch to internal model training at work. Autoresearch loops optimizing the training of the models that run the loops is the recursion everyone talks about abstractly, and here it is showing up as a Tuesday work update.
https://x.com/penstrokes75/status/2086863517043617898
Short, but it moves autoresearch into the place that matters most. He reports seeing some success applying autoresearch to internal model training at work. Autoresearch loops optimizing the training of the models that run the loops is the recursion everyone talks about abstractly, and here it is showing up as a Tuesday work update.
#14
@sys0ut
https://x.com/sys0ut/status/2086831642845364298
Autoresearch pointed at a very narrow, very verifiable target: small CUDA kernels for polynomial multiplication, now that NVIDIA added clmad. This is the ideal shape for these loops - a tiny search space, an unambiguous correctness check, and a single number to maximize. Note it is the second kernel-optimization autoresearch project in this edition alone.
https://x.com/sys0ut/status/2086831642845364298
Autoresearch pointed at a very narrow, very verifiable target: small CUDA kernels for polynomial multiplication, now that NVIDIA added clmad. This is the ideal shape for these loops - a tiny search space, an unambiguous correctness check, and a single number to maximize. Note it is the second kernel-optimization autoresearch project in this edition alone.
#15
@andrey_cheptsov
https://x.com/andrey_cheptsov/status/2086872862825082979
Autoresearch as a hosted service rather than a setup you assemble: Transformer Lab launched Primus, which automates the full research loop - it reads papers, forms hypotheses, writes code, runs experiments, and writes the final paper. His framing is that autoresearch is a real shift in how AI itself is built, and he credits dstack for the compute orchestration side, which is the unglamorous half nobody markets.
https://x.com/andrey_cheptsov/status/2086872862825082979
Autoresearch as a hosted service rather than a setup you assemble: Transformer Lab launched Primus, which automates the full research loop - it reads papers, forms hypotheses, writes code, runs experiments, and writes the final paper. His framing is that autoresearch is a real shift in how AI itself is built, and he credits dstack for the compute orchestration side, which is the unglamorous half nobody markets.
#16
@menlotimes
https://x.com/menlotimes/status/2086822967846289595
Autoresearch for the lab, funded. Discovered Materials launched with a $9M seed led by Lightspeed with YC, Peak XV and angels including Paul Graham and Gokul Rajaram, aimed at one of AI's biggest physical constraints: heat, with modern GPUs generating around 140 W/cmΒ², more than a space shuttle nose cone during re-entry. The bottleneck they name is not discovering materials but getting them from lab to fab, a process that can take years and hundreds of millions. Their agents simulate, synthesize and test materials to compress months of interdisciplinary research into days, and during YC the team says it developed thermal interface materials matching the performance of products guarded as industry trade secrets for 20+ years.
https://x.com/menlotimes/status/2086822967846289595
Autoresearch for the lab, funded. Discovered Materials launched with a $9M seed led by Lightspeed with YC, Peak XV and angels including Paul Graham and Gokul Rajaram, aimed at one of AI's biggest physical constraints: heat, with modern GPUs generating around 140 W/cmΒ², more than a space shuttle nose cone during re-entry. The bottleneck they name is not discovering materials but getting them from lab to fab, a process that can take years and hundreds of millions. Their agents simulate, synthesize and test materials to compress months of interdisciplinary research into days, and during YC the team says it developed thermal interface materials matching the performance of products guarded as industry trade secrets for 20+ years.
#17
@Synapse_Brief
https://x.com/Synapse_Brief/status/2086829648281833735
The structural news of the day, and where it points is unambiguous. Jeff Dean, Sanjay Ghemawat, Oriol Vinyals and Quoc Le are gone from Google - twenty seven years of Dean's tenure ended - to build an autoresearch startup called Discovery Loop, with Alphabet as a founding investor, which tells you how that exit conversation went. It lands the same day Google named who is building Gemini 4, and Alphabet stock dropped about 5%. When four of the most senior technical figures at the company that invented the transformer leave specifically to industrialize the propose-run-evaluate loop, autoresearch stops being a Twitter genre and becomes an industry.
https://x.com/Synapse_Brief/status/2086829648281833735
The structural news of the day, and where it points is unambiguous. Jeff Dean, Sanjay Ghemawat, Oriol Vinyals and Quoc Le are gone from Google - twenty seven years of Dean's tenure ended - to build an autoresearch startup called Discovery Loop, with Alphabet as a founding investor, which tells you how that exit conversation went. It lands the same day Google named who is building Gemini 4, and Alphabet stock dropped about 5%. When four of the most senior technical figures at the company that invented the transformer leave specifically to industrialize the propose-run-evaluate loop, autoresearch stops being a Twitter genre and becomes an industry.
#18
@xdotli
https://x.com/xdotli/status/2086898143493558573
The same event read as a timing signal rather than as gossip. Jeff Dean left Google to start Discovery Loop, automating the full scientific discovery cycle, and Karpathy brought auto-research into the spotlight earlier this year. His conclusion is the one worth holding: AI-driven scientific research is not a future trend, it is happening. On the evidence in this single edition - kernel competitions, materials science, model architecture search, internal model training, cryptographic provers - that is hard to dispute.
https://x.com/xdotli/status/2086898143493558573
The same event read as a timing signal rather than as gossip. Jeff Dean left Google to start Discovery Loop, automating the full scientific discovery cycle, and Karpathy brought auto-research into the spotlight earlier this year. His conclusion is the one worth holding: AI-driven scientific research is not a future trend, it is happening. On the evidence in this single edition - kernel competitions, materials science, model architecture search, internal model training, cryptographic provers - that is hard to dispute.
#19
@code_hiyouga
https://x.com/code_hiyouga/status/2086836278272913526
Two sentences that name the actual open problem. RSI and auto research share some of the same nature, and the next step is to make AI responsible for producing generalizable results. That word generalizable is the whole difficulty: every result in this edition is a number on one specific target, and the field has no mechanism yet for an autoresearch loop to discover something that transfers beyond the benchmark it was pointed at.
https://x.com/code_hiyouga/status/2086836278272913526
Two sentences that name the actual open problem. RSI and auto research share some of the same nature, and the next step is to make AI responsible for producing generalizable results. That word generalizable is the whole difficulty: every result in this edition is a number on one specific target, and the field has no mechanism yet for an autoresearch loop to discover something that transfers beyond the benchmark it was pointed at.
#20
@dviolettchan
https://x.com/dviolettchan/status/2086873120862793956
The reward-hacking observation the field will have to answer soon, delivered as a joke. If an AI review is the real review, that is a wonderful example of reward hacking - he can just do things with auto-research and care less, play more video games, and still get accepted. The uncomfortable part is that this is structurally identical to the verifier-strength term in the progress formula. If the verifier is an AI reviewer and the producer is an autoresearch loop, you have closed a circuit with no outside contact.
https://x.com/dviolettchan/status/2086873120862793956
The reward-hacking observation the field will have to answer soon, delivered as a joke. If an AI review is the real review, that is a wonderful example of reward hacking - he can just do things with auto-research and care less, play more video games, and still get accepted. The uncomfortable part is that this is structurally identical to the verifier-strength term in the progress formula. If the verifier is an AI reviewer and the producer is an autoresearch loop, you have closed a circuit with no outside contact.
#21
@liuzhao_666
https://x.com/liuzhao_666/status/2086907650084941902
One sentence that is the correct answer to the problem above. Self-improving loops need a protected evaluation set, because without a fixed holdout, every optimization can quietly teach the agent to game its own metric. The word quietly is doing the work - a loop that games its metric reports improvement, so the failure is invisible from inside the loop and only shows up when you finally test on something it never saw.
https://x.com/liuzhao_666/status/2086907650084941902
One sentence that is the correct answer to the problem above. Self-improving loops need a protected evaluation set, because without a fixed holdout, every optimization can quietly teach the agent to game its own metric. The word quietly is doing the work - a loop that games its metric reports improvement, so the failure is invisible from inside the loop and only shows up when you finally test on something it never saw.
#22
@stas_sorokin_
https://x.com/stas_sorokin_/status/2086804278362988778
The measurement discipline this whole field is missing, in checklist form. Fastest is not a benchmark, it is a claim nobody has to defend - every open source agent release ships with a speed claim and almost none say what was actually timed, because raw token throughput and full task completion time are different numbers and vendors pick whichever flatters the release. The item most reviews skip entirely is agent loop overhead: the planning steps, tool calls and retries that happen between the model producing tokens, meaning a model can win on raw generation speed and still lose the actual task because the loop around it is slow. Before trusting any such claim, check the hardware and precision, whether the number is throughput or end-to-end completion, whether loop overhead is included or stripped out, whether the comparison ran the same task with the same context length and tool set, whether the weights are actually open rather than branded open, and whether you can rerun it yourself. His rule: adopt nothing into a production pipeline on a number you cannot rerun.
https://x.com/stas_sorokin_/status/2086804278362988778
The measurement discipline this whole field is missing, in checklist form. Fastest is not a benchmark, it is a claim nobody has to defend - every open source agent release ships with a speed claim and almost none say what was actually timed, because raw token throughput and full task completion time are different numbers and vendors pick whichever flatters the release. The item most reviews skip entirely is agent loop overhead: the planning steps, tool calls and retries that happen between the model producing tokens, meaning a model can win on raw generation speed and still lose the actual task because the loop around it is slow. Before trusting any such claim, check the hardware and precision, whether the number is throughput or end-to-end completion, whether loop overhead is included or stripped out, whether the comparison ran the same task with the same context length and tool set, whether the weights are actually open rather than branded open, and whether you can rerun it yourself. His rule: adopt nothing into a production pipeline on a number you cannot rerun.
#23
@0xShoopy
https://x.com/0xShoopy/status/2086787604523999497
The best harness demo report of the day, and the punchline is in the first line: an Anthropic engineer deleted 90% of the setup and the agent got faster. She shipped a full incident response agent in 6 functions, and it debugged a P99 spike before she finished the demo. The historical detail is the interesting one - Sonnet 4.5 had context anxiety and wrapped up tasks early with room to spare, they patched the harness to compensate, then Opus shipped and the behavior vanished on its own, which is the strongest possible argument for the delete-your-patches advice going around. Architecturally they split brain from hands: agent loop server-side, tools in a sandbox, and time to first token dropped 90%. System prompt was 6 lines, the agent ran on 3 local tools, no MCP chaos, and a hard refresh mid-session lost nothing with no database wired up. His closing line is the thesis of this entire edition: the model was never the bottleneck, the harness was.
https://x.com/0xShoopy/status/2086787604523999497
The best harness demo report of the day, and the punchline is in the first line: an Anthropic engineer deleted 90% of the setup and the agent got faster. She shipped a full incident response agent in 6 functions, and it debugged a P99 spike before she finished the demo. The historical detail is the interesting one - Sonnet 4.5 had context anxiety and wrapped up tasks early with room to spare, they patched the harness to compensate, then Opus shipped and the behavior vanished on its own, which is the strongest possible argument for the delete-your-patches advice going around. Architecturally they split brain from hands: agent loop server-side, tools in a sandbox, and time to first token dropped 90%. System prompt was 6 lines, the agent ran on 3 local tools, no MCP chaos, and a hard refresh mid-session lost nothing with no database wired up. His closing line is the thesis of this entire edition: the model was never the bottleneck, the harness was.
#24
@mhtuie52
https://x.com/mhtuie52/status/2086835994968338916
Stripe's internal agent, and the number that should reset how you think about skill libraries. One engineer built Kai in a week; 83% of Stripe now uses it weekly. It sits on top of 1,000+ skills and 500+ internal tools, and the obvious move would be to dump all of that into context - Stripe found the opposite, because past roughly 150 skills frontier models start getting worse. So Kai does two passes: first it decides which skills the request actually needs, and only then do those skills load their tools, giving a chain of 1,000+ skills to selected skills to their tools to the agent loop. Then Stripe separates brain from hands, with the agent staying outside the sandbox while model-written code runs inside it, isolated from the process that created it. The conclusion is the one to keep: they did not scale Kai by giving the model access to everything, they scaled it by teaching the system what not to show the model. More capability does not require more context, it requires better exclusion.
https://x.com/mhtuie52/status/2086835994968338916
Stripe's internal agent, and the number that should reset how you think about skill libraries. One engineer built Kai in a week; 83% of Stripe now uses it weekly. It sits on top of 1,000+ skills and 500+ internal tools, and the obvious move would be to dump all of that into context - Stripe found the opposite, because past roughly 150 skills frontier models start getting worse. So Kai does two passes: first it decides which skills the request actually needs, and only then do those skills load their tools, giving a chain of 1,000+ skills to selected skills to their tools to the agent loop. Then Stripe separates brain from hands, with the agent staying outside the sandbox while model-written code runs inside it, isolated from the process that created it. The conclusion is the one to keep: they did not scale Kai by giving the model access to everything, they scaled it by teaching the system what not to show the model. More capability does not require more context, it requires better exclusion.
#25
@_vmlops
https://x.com/_vmlops/status/2086734873692381618
The same session read as an architecture rather than a demo, and the three-word model is worth borrowing: Agents are the brain, Environments are the hands, Sessions are the glue. Claude Managed Agents runs the agent loop server-side without you managing hosting or scaling, tool execution is decoupled, and sessions survive refreshes. Reported alongside it: 90%+ lower P95 time-to-first-token, bring-your-own-compute, encrypted credential vaults, sub-agents, memory, outcomes and webhook triggers. The live build was an SRE agent that investigated a P99 latency spike, analyzed metrics, deployments and diffs, and traced it back to the exact commit causing the incident.
https://x.com/_vmlops/status/2086734873692381618
The same session read as an architecture rather than a demo, and the three-word model is worth borrowing: Agents are the brain, Environments are the hands, Sessions are the glue. Claude Managed Agents runs the agent loop server-side without you managing hosting or scaling, tool execution is decoupled, and sessions survive refreshes. Reported alongside it: 90%+ lower P95 time-to-first-token, bring-your-own-compute, encrypted credential vaults, sub-agents, memory, outcomes and webhook triggers. The live build was an SRE agent that investigated a P99 latency spike, analyzed metrics, deployments and diffs, and traced it back to the exact commit causing the incident.
#26
@0xNeuroBlue
https://x.com/0xNeuroBlue/status/2086616125375144384
The cleanest definition of an agent loop anyone offered, credited to a Google engineer: it executes it, and then checks its own work. Writes, runs, checks - drop the third and you do not have an agent, you have a generator. The talk he is pointing at spends twenty minutes on what happens when you drop it, with timestamps: at 8:57 the app would have stopped working, at 9:02 the review that catches it, and at 12:09 what memory quietly forgets.
https://x.com/0xNeuroBlue/status/2086616125375144384
The cleanest definition of an agent loop anyone offered, credited to a Google engineer: it executes it, and then checks its own work. Writes, runs, checks - drop the third and you do not have an agent, you have a generator. The talk he is pointing at spends twenty minutes on what happens when you drop it, with timestamps: at 8:57 the app would have stopped working, at 9:02 the review that catches it, and at 12:09 what memory quietly forgets.
#27
@onusoz
https://x.com/onusoz/status/2086844493672980650
The most inventive thing anybody built in this edition, and it started from an annoyance. Codex's desktop app can keep track of a task until it is properly finished - basically cron - and the CLI still cannot, so he built his own in Pi. Then he realized a cron job is a loop, and being a loop, he could represent it as a workflow graph. So he made a built-in monitor workflow: the agent is forced into a loop where it re-checks a very long-running job every hour and is instructed to autonomously correct it and fix any bugs encountered. The reason he prefers this over exec-based approaches is the key insight - his monitor workflow is deterministic, so he can make the agent loop infinitely and there is nothing the agent can do to evade the task, whereas with auto-forking exec the model might mess up exec or fail to re-arm the next sleep. This lets him fire off week-long jobs and forget about them, and it even survives Codex usage depletion by auto-recovering once his quota resets.
https://x.com/onusoz/status/2086844493672980650
The most inventive thing anybody built in this edition, and it started from an annoyance. Codex's desktop app can keep track of a task until it is properly finished - basically cron - and the CLI still cannot, so he built his own in Pi. Then he realized a cron job is a loop, and being a loop, he could represent it as a workflow graph. So he made a built-in monitor workflow: the agent is forced into a loop where it re-checks a very long-running job every hour and is instructed to autonomously correct it and fix any bugs encountered. The reason he prefers this over exec-based approaches is the key insight - his monitor workflow is deterministic, so he can make the agent loop infinitely and there is nothing the agent can do to evade the task, whereas with auto-forking exec the model might mess up exec or fail to re-arm the next sleep. This lets him fire off week-long jobs and forget about them, and it even survives Codex usage depletion by auto-recovering once his quota resets.
#28
@thdxr
https://x.com/thdxr/status/2086946190914896228
The most-engaged agent-loop post of the day is a complaint, and it is a real architectural point. The coupling of a filesystem to agents was so dumb - if you want to support skills even for a dumb in-memory agent loop, you need a virtual fs. Skills as a format assume a directory on disk, which quietly means every agent runtime that is not a shell on a machine has to fake one.
https://x.com/thdxr/status/2086946190914896228
The most-engaged agent-loop post of the day is a complaint, and it is a real architectural point. The coupling of a filesystem to agents was so dumb - if you want to support skills even for a dumb in-memory agent loop, you need a virtual fs. Skills as a format assume a directory on disk, which quietly means every agent runtime that is not a shell on a machine has to fake one.
#29
@0xblacklight
https://x.com/0xblacklight/status/2086959427224211837
The direct answer to that complaint, which is why it belongs here: if you are using a dumb in-memory agent loop, just make the harness load from memory, or allow the caller to specify a callback. Two lines that turn a format complaint into an interface design question - the skills spec does not actually require a filesystem, it requires a resolver, and most implementations hardcoded the wrong one.
https://x.com/0xblacklight/status/2086959427224211837
The direct answer to that complaint, which is why it belongs here: if you are using a dumb in-memory agent loop, just make the harness load from memory, or allow the caller to specify a callback. Two lines that turn a format complaint into an interface design question - the skills spec does not actually require a filesystem, it requires a resolver, and most implementations hardcoded the wrong one.
#30
@stretchcloud
https://x.com/stretchcloud/status/2086672639146504505
The most useful paper summary in this edition, and the premise reframes where agent latency comes from. The bottleneck in agentic inference is not the reasoning step, it is the tool call: every time an agent picks a function and fills in arguments, the main model generates those tokens one at a time, which is a lot of serial work on a path that runs hundreds of times per session. OoO-Spec attacks this with a Qwen3-0.6B sidecar that predicts the function name and all argument values in one parallel wave while the main model is still processing, with the main model verifying without blocking and remaining the sole commit authority. Results: 2.46 to 5.34x faster than autoregressive decoding, 3.89x on average, and it beats ToolSpec by 34.1% on Qwen3 4B through 32B. What makes it notable is that the same 0.6B drafter transfers across Qwen2.5, Qwen3 and Llama with no target-specific retraining - one small model covers all sizes and families. From University of Tokyo and Peking University, no product yet, but the implementation surface is small enough that this ships as a library soon.
https://x.com/stretchcloud/status/2086672639146504505
The most useful paper summary in this edition, and the premise reframes where agent latency comes from. The bottleneck in agentic inference is not the reasoning step, it is the tool call: every time an agent picks a function and fills in arguments, the main model generates those tokens one at a time, which is a lot of serial work on a path that runs hundreds of times per session. OoO-Spec attacks this with a Qwen3-0.6B sidecar that predicts the function name and all argument values in one parallel wave while the main model is still processing, with the main model verifying without blocking and remaining the sole commit authority. Results: 2.46 to 5.34x faster than autoregressive decoding, 3.89x on average, and it beats ToolSpec by 34.1% on Qwen3 4B through 32B. What makes it notable is that the same 0.6B drafter transfers across Qwen2.5, Qwen3 and Llama with no target-specific retraining - one small model covers all sizes and families. From University of Tokyo and Peking University, no product yet, but the implementation surface is small enough that this ships as a library soon.
#31
@zaoyang
https://x.com/zaoyang/status/2086816355399999911
The most technically substantial post of the day, and the part that belongs in this edition is a warning about a speedup you cannot actually capture. Kimi Delta Attention, the hybrid linear-attention mechanism running in 3 of every 4 layers, is what gives K3 its reported up-to-6.3x faster decoding at 1M-token context. But testers flagged that KDA breaks the assumptions behind conventional prefix caching - the trick that lets a serving system reuse attention state for a shared prompt prefix across many requests, which matters enormously for coding agents that re-send huge, mostly identical contexts over and over. A linear-attention layer carries a running recurrent state instead of a plain key/value cache, so cache-the-prefix does not drop in cleanly, and it needs runtime changes upstream before you actually capture the speedup inside a real agent loop. He also notes the 3:1 ratio is a measured sweet spot rather than a knob - the precursor work ablated it, with 7:1 keeping training loss comparable but making validation noticeably worse, and 1:1 holding validation but pushing inference overhead back up.
https://x.com/zaoyang/status/2086816355399999911
The most technically substantial post of the day, and the part that belongs in this edition is a warning about a speedup you cannot actually capture. Kimi Delta Attention, the hybrid linear-attention mechanism running in 3 of every 4 layers, is what gives K3 its reported up-to-6.3x faster decoding at 1M-token context. But testers flagged that KDA breaks the assumptions behind conventional prefix caching - the trick that lets a serving system reuse attention state for a shared prompt prefix across many requests, which matters enormously for coding agents that re-send huge, mostly identical contexts over and over. A linear-attention layer carries a running recurrent state instead of a plain key/value cache, so cache-the-prefix does not drop in cleanly, and it needs runtime changes upstream before you actually capture the speedup inside a real agent loop. He also notes the 3:1 ratio is a measured sweet spot rather than a knob - the precursor work ablated it, with 7:1 keeping training loss comparable but making validation noticeably worse, and 1:1 holding validation but pushing inference overhead back up.
#32
@vsaietta
https://x.com/vsaietta/status/2086788305689964552
One number that explains most agent bills, and it inverts the intuition about caching. Cached input is the line that actually adds up: $29.73 versus $5.68 fresh, despite being priced at a tenth of the rate. That is what an agentic loop rereading the same context on every follow-up turn costs at scale, not the fresh tokens. A discount of 90% per token still loses to a 10x increase in tokens read, and a loop is exactly the machine that produces that increase.
https://x.com/vsaietta/status/2086788305689964552
One number that explains most agent bills, and it inverts the intuition about caching. Cached input is the line that actually adds up: $29.73 versus $5.68 fresh, despite being priced at a tenth of the rate. That is what an agentic loop rereading the same context on every follow-up turn costs at scale, not the fresh tokens. A discount of 90% per token still loses to a 10x increase in tokens read, and a loop is exactly the machine that produces that increase.
#33
@0xMukay
https://x.com/0xMukay/status/2086723081985269816
The economics framing this edition needs, and the metric he proposes is the right one. Most people running AI agents track how fast the agent works; the only number that matters is how much the agent costs per correct decision. A Claude Code session running an autonomous agent loop burns anywhere from $2 to $40 in compute per hour depending on model choice and context length, and most people do not know their exact number - they just know the subscription feels cheap. It is not cheap, it is subsidized, and while attempts to end flat-rate agents keep getting reversed, the direction is confirmed. The builders who survive that transition already know their cost per output: they route cheap tasks to Haiku, reserve Opus for decisions that need it, and run prompt caching on repeated context. His closing line: AI agents are not tools, they are infrastructure with a meter running.
https://x.com/0xMukay/status/2086723081985269816
The economics framing this edition needs, and the metric he proposes is the right one. Most people running AI agents track how fast the agent works; the only number that matters is how much the agent costs per correct decision. A Claude Code session running an autonomous agent loop burns anywhere from $2 to $40 in compute per hour depending on model choice and context length, and most people do not know their exact number - they just know the subscription feels cheap. It is not cheap, it is subsidized, and while attempts to end flat-rate agents keep getting reversed, the direction is confirmed. The builders who survive that transition already know their cost per output: they route cheap tasks to Haiku, reserve Opus for decisions that need it, and run prompt caching on repeated context. His closing line: AI agents are not tools, they are infrastructure with a meter running.
#34
@helli0nEth
https://x.com/helli0nEth/status/2086904292103897508
The same point as a single image, and it is the best sentence in this edition. He has watched an agent loop on a broken test for forty minutes and burn tokens the whole time - on metered inference that is a line item, on local weights it is a warm room. The distinction is the entire argument for local models in agent workloads, and nobody has put it more compactly.
https://x.com/helli0nEth/status/2086904292103897508
The same point as a single image, and it is the best sentence in this edition. He has watched an agent loop on a broken test for forty minutes and burn tokens the whole time - on metered inference that is a line item, on local weights it is a warm room. The distinction is the entire argument for local models in agent workloads, and nobody has put it more compactly.
#35
@rtheoryxyz
https://x.com/rtheoryxyz/status/2086912890980675724
The structural consequence of all that pricing, stated in one line. The hidden issue is that tool forcing makes the cache boundary part of the product surface, and once pricing leaks into architecture, every agent loop starts optimizing around invoices instead of intent. Read alongside the $29.73 cached-input number and the harness cost swings, this is the mechanism by which billing design quietly becomes system design.
https://x.com/rtheoryxyz/status/2086912890980675724
The structural consequence of all that pricing, stated in one line. The hidden issue is that tool forcing makes the cache boundary part of the product surface, and once pricing leaks into architecture, every agent loop starts optimizing around invoices instead of intent. Read alongside the $29.73 cached-input number and the harness cost swings, this is the mechanism by which billing design quietly becomes system design.
#36
@maria_airealist
https://x.com/maria_airealist/status/2086842065141342713
The sharpest critique of the whole agentic stack in this edition, and it is a list of bandages. Inability to learn new stuff is masked by saving logs in memory.md plus RAG. Inability to be deterministic, and prompt sensitivity, are masked by LLMs writing code and executing it or calling tools. Inability to tell right from wrong is masked by the agentic loop validation step. Her verdict: it kind of works, but it is kind of bandages, particularly the continual learning part. Every one of those three maps directly onto a category of tool in this edition, which is either a devastating reading or a description of how engineering has always worked.
https://x.com/maria_airealist/status/2086842065141342713
The sharpest critique of the whole agentic stack in this edition, and it is a list of bandages. Inability to learn new stuff is masked by saving logs in memory.md plus RAG. Inability to be deterministic, and prompt sensitivity, are masked by LLMs writing code and executing it or calling tools. Inability to tell right from wrong is masked by the agentic loop validation step. Her verdict: it kind of works, but it is kind of bandages, particularly the continual learning part. Every one of those three maps directly onto a category of tool in this edition, which is either a devastating reading or a description of how engineering has always worked.
#37
@raulvk
https://x.com/raulvk/status/2086843993661329710
The funniest accurate description of the review loop, and everybody who has done this recognizes it. These models are sneaky psychopaths: at design time they convince you they just get it, and you walk away thinking they will ace the task. Then you review the implementation and they have shat the bed. You ask for corrections, they get it, you review again, and they have shat a different part of the bed. Ah, such joy, the true agentic loop.
https://x.com/raulvk/status/2086843993661329710
The funniest accurate description of the review loop, and everybody who has done this recognizes it. These models are sneaky psychopaths: at design time they convince you they just get it, and you walk away thinking they will ace the task. Then you review the implementation and they have shat the bed. You ask for corrections, they get it, you review again, and they have shat a different part of the bed. Ah, such joy, the true agentic loop.
#38
@kentcdodds
https://x.com/kentcdodds/status/2086894806404567102
A one-line principle worth designing around: agent feedback is fantastic when the agent that gets the feedback is the one that works on the fix. Talk about an agentic loop. Most feedback tooling routes signal to a human who then relays it, and the relay is where the loop breaks - the fix is to close it, not to speed up the relay.
https://x.com/kentcdodds/status/2086894806404567102
A one-line principle worth designing around: agent feedback is fantastic when the agent that gets the feedback is the one that works on the fix. Talk about an agentic loop. Most feedback tooling routes signal to a human who then relays it, and the relay is where the loop breaks - the fix is to close it, not to speed up the relay.
#39
@KiraFeed
https://x.com/KiraFeed/status/2086629230809317497
Design as an agentic loop, and the author correctly identifies which half is impressive. The impressive part is not that Claude can design in Figma - it is that it can look at what it made and say this still looks bad, then fix it. Claude plus Figma MCP is basically turning design into an agentic loop. Self-critique on a visual artifact is a verifier for a domain that was supposed to be unverifiable, which is exactly the barrier that kept these loops confined to code and kernels.
https://x.com/KiraFeed/status/2086629230809317497
Design as an agentic loop, and the author correctly identifies which half is impressive. The impressive part is not that Claude can design in Figma - it is that it can look at what it made and say this still looks bad, then fix it. Claude plus Figma MCP is basically turning design into an agentic loop. Self-critique on a visual artifact is a verifier for a domain that was supposed to be unverifiable, which is exactly the barrier that kept these loops confined to code and kernels.
#40
@kuo_chesterkuo
https://x.com/kuo_chesterkuo/status/2086689959940128840
An autonomous offensive loop shipped as a product, and the design principle separates it from scanners. Most AI security tools pattern-match known signatures; here GLM 5.2 drives the entire offensive loop as an autonomous agent - it maps the application's attack surface, crafts and launches real safe exploit payloads, chains findings, and confirms each one with a working proof-of-concept mapped to the full OWASP Top 10 2025. That means active exploitation rather than passive scanning, with every finding backed by a real PoC plus request and response evidence, which is what cuts false positives. Coverage spans injection, broken access control including BOLA and IDOR, SSRF, JWT, GraphQL, deserialization and business-logic flaws. His note on the requirement is the relevant part: an autonomous pentester only works if the model can truly reason and use tools across a long agentic loop.
https://x.com/kuo_chesterkuo/status/2086689959940128840
An autonomous offensive loop shipped as a product, and the design principle separates it from scanners. Most AI security tools pattern-match known signatures; here GLM 5.2 drives the entire offensive loop as an autonomous agent - it maps the application's attack surface, crafts and launches real safe exploit payloads, chains findings, and confirms each one with a working proof-of-concept mapped to the full OWASP Top 10 2025. That means active exploitation rather than passive scanning, with every finding backed by a real PoC plus request and response evidence, which is what cuts false positives. Coverage spans injection, broken access control including BOLA and IDOR, SSRF, JWT, GraphQL, deserialization and business-logic flaws. His note on the requirement is the relevant part: an autonomous pentester only works if the model can truly reason and use tools across a long agentic loop.
#41
@cyberneticphysx
https://x.com/cyberneticphysx/status/2086669577027792907
The best statement of why a world model does not remove the need for a verifier. Physics-based world models are not here to replace simulators - they are the missing piece required to scale RL in robotics effectively. Say you have an agentic loop where a world model's role is to dream up the next state: you still need the simulator in the loop to anchor the planning, because the simulator is the more expensive and more verifiable step, while the dreaming loop becomes the quicker yet necessary approximation. Cheap-approximation plus expensive-anchor is structurally the same pattern as the sidecar drafter and the two-pass skill selection elsewhere in this edition.
https://x.com/cyberneticphysx/status/2086669577027792907
The best statement of why a world model does not remove the need for a verifier. Physics-based world models are not here to replace simulators - they are the missing piece required to scale RL in robotics effectively. Say you have an agentic loop where a world model's role is to dream up the next state: you still need the simulator in the loop to anchor the planning, because the simulator is the more expensive and more verifiable step, while the dreaming loop becomes the quicker yet necessary approximation. Cheap-approximation plus expensive-anchor is structurally the same pattern as the sidecar drafter and the two-pass skill selection elsewhere in this edition.
#42
@nickthorpp
https://x.com/nickthorpp/status/2086785078512828744
The right question to ask about every local model release, and almost nobody asks it. He agrees 30B dense for 24GB is the current sweet spot, then makes the distinction that matters: in practice the bigger unlock is not just that it runs, it is whether the agentic loop stays stable without constant context truncation or tool-call failures when you are running long-horizon tasks locally. His open question - has anyone seen a new 30B-class model actually hold reliability under multi-tool, multi-turn agent workloads - is the benchmark the entire local-agent wave is missing.
https://x.com/nickthorpp/status/2086785078512828744
The right question to ask about every local model release, and almost nobody asks it. He agrees 30B dense for 24GB is the current sweet spot, then makes the distinction that matters: in practice the bigger unlock is not just that it runs, it is whether the agentic loop stays stable without constant context truncation or tool-call failures when you are running long-horizon tasks locally. His open question - has anyone seen a new 30B-class model actually hold reliability under multi-tool, multi-turn agent workloads - is the benchmark the entire local-agent wave is missing.
#43
@sanjaybhadra
https://x.com/sanjaybhadra/status/2086804771781099816
Why one local-model demo was more compelling than the benchmark table, and the reason is completion rather than capability. The Muse Glimmer demo completed the entire local-agent loop: discover Home Assistant, understand its APIs, build a dashboard, launch it, and verify it. If it holds up beyond the demo, he expects many private home networking, camera and automation projects to be attempted by non-technical or semi-technical people. Note that verify is the fifth step and the one that makes it a loop rather than a script.
https://x.com/sanjaybhadra/status/2086804771781099816
Why one local-model demo was more compelling than the benchmark table, and the reason is completion rather than capability. The Muse Glimmer demo completed the entire local-agent loop: discover Home Assistant, understand its APIs, build a dashboard, launch it, and verify it. If it holds up beyond the demo, he expects many private home networking, camera and automation projects to be attempted by non-technical or semi-technical people. Note that verify is the fifth step and the one that makes it a loop rather than a script.
#44
@cozybearlog
https://x.com/cozybearlog/status/2086678165016220050
A multimodal layer for every harness at once, and the strategic read is the interesting half. Qwen open sourced Qwen-MM-Plugins, a plugin set that turns any agent harness - Claude Code, Codex, Gemini CLI - into a multimodal-native one, putting screens, videos, PDFs and 3D/CAD files straight into the agent loop. He names the gap precisely: every harness today thinks in text, but the world it operates on is screens and files, and while model vendors race to make models that see, the winning harness might be the one that plugs vision in without making you re-architect. The playbook is worth noting on its own - instead of competing with the harnesses, ship the plugin that upgrades all of them, which is how you win a standards war without owning the platform.
https://x.com/cozybearlog/status/2086678165016220050
A multimodal layer for every harness at once, and the strategic read is the interesting half. Qwen open sourced Qwen-MM-Plugins, a plugin set that turns any agent harness - Claude Code, Codex, Gemini CLI - into a multimodal-native one, putting screens, videos, PDFs and 3D/CAD files straight into the agent loop. He names the gap precisely: every harness today thinks in text, but the world it operates on is screens and files, and while model vendors race to make models that see, the winning harness might be the one that plugs vision in without making you re-architect. The playbook is worth noting on its own - instead of competing with the harnesses, ship the plugin that upgrades all of them, which is how you win a standards war without owning the platform.
#45
@jerryjliu0
https://x.com/jerryjliu0/status/2086915480389111830
A latency argument for boring technology, placed exactly where it matters. A downside with VLM-based parsing is that it is generally slower than text-based heuristic approaches, so it adds latency to any ad-hoc file processing in the agent loop - for example when you upload a file to Claude. LiteParse is built to be a really good text-based heuristic extractor so it can be the default parser in the agent loop: 4ms to parse 200 pages, more accurate than other open source parsers, installable inside Claude Cowork, Claude Code or Codex in one line with an agent skill. It supports 50+ document formats and has a native complexity router so you can send genuinely complex pages on to OCR or VLMs. Fast default plus escalation path is the correct shape, and it is the third instance of that shape in this edition.
https://x.com/jerryjliu0/status/2086915480389111830
A latency argument for boring technology, placed exactly where it matters. A downside with VLM-based parsing is that it is generally slower than text-based heuristic approaches, so it adds latency to any ad-hoc file processing in the agent loop - for example when you upload a file to Claude. LiteParse is built to be a really good text-based heuristic extractor so it can be the default parser in the agent loop: 4ms to parse 200 pages, more accurate than other open source parsers, installable inside Claude Cowork, Claude Code or Codex in one line with an agent skill. It supports 50+ document formats and has a native complexity router so you can send genuinely complex pages on to OCR or VLMs. Fast default plus escalation path is the correct shape, and it is the third instance of that shape in this edition.
#46
@stretchcloud
https://x.com/stretchcloud/status/2086876670007419034
What changes when inference gets cheap, and the answer is that the bottleneck moves rather than disappears. Three weeks ago $7.23 per coding task made you deliberate about what to feed into an agent loop; today at $0.12 those economics change, so teams that were throttling pipeline usage are now running far more tasks and need reliable data feeding in at higher volume. That is where extraction quality starts to matter more than it used to. DeepScraper uses fit-markdown: when it fetches a page it strips layout noise and serializes only the content-dense parts of the DOM, producing clean markdown that fits in context windows without burning tokens on nav bars and footers. Because it derives a deterministic CSS selector on first scrape, subsequent runs skip parsing entirely, reusing the cached selector until site structure changes and then re-deriving automatically. His line is the keeper: a bad extraction at $7 is still just a bad extraction, but at $0.12 you might be doing it 60x as often.
https://x.com/stretchcloud/status/2086876670007419034
What changes when inference gets cheap, and the answer is that the bottleneck moves rather than disappears. Three weeks ago $7.23 per coding task made you deliberate about what to feed into an agent loop; today at $0.12 those economics change, so teams that were throttling pipeline usage are now running far more tasks and need reliable data feeding in at higher volume. That is where extraction quality starts to matter more than it used to. DeepScraper uses fit-markdown: when it fetches a page it strips layout noise and serializes only the content-dense parts of the DOM, producing clean markdown that fits in context windows without burning tokens on nav bars and footers. Because it derives a deterministic CSS selector on first scrape, subsequent runs skip parsing entirely, reusing the cached selector until site structure changes and then re-deriving automatically. His line is the keeper: a bad extraction at $7 is still just a bad extraction, but at $0.12 you might be doing it 60x as often.
#47
@exploraX_
https://x.com/exploraX_/status/2086926463392235899
An MCP server collection with three rules attached, and the rules are better than the list. The repo holds the top 50 MCP servers for Claude, Gemini and Codex, MIT licensed, grouped into 9 categories with the exact install command for all three agents. Then: do not install 50, because past 5-7 connected servers your agent chokes on tool bloat and gets slower and dumber. Treat every server like a CLI from a stranger's github - pin versions, keep tokens read-only until you have watched it work. And never point an agent loop at production, use a read replica. The first rule is the same finding Stripe hit at 150 skills, arriving at a much smaller scale, and the third is the one the gym-booking incident in today's other edition exists to illustrate.
https://x.com/exploraX_/status/2086926463392235899
An MCP server collection with three rules attached, and the rules are better than the list. The repo holds the top 50 MCP servers for Claude, Gemini and Codex, MIT licensed, grouped into 9 categories with the exact install command for all three agents. Then: do not install 50, because past 5-7 connected servers your agent chokes on tool bloat and gets slower and dumber. Treat every server like a CLI from a stranger's github - pin versions, keep tokens read-only until you have watched it work. And never point an agent loop at production, use a read replica. The first rule is the same finding Stripe hit at 150 skills, arriving at a much smaller scale, and the third is the one the gym-booking incident in today's other edition exists to illustrate.
#48
@HermesWatcher
https://x.com/HermesWatcher/status/2086935645319295276
A configuration detail that quietly doubles some people's bills, and almost nobody checks it. Most people think Hermes has one model decision; it really has two. Your main model runs the agent loop - the conversation, reasoning, tool calls and responses - but Hermes also has auxiliary model slots for side jobs like context compression, web extraction, vision, approvals, Skills Hub search, MCP helper work and session titles. The part worth checking is auto: when an auxiliary slot is set to auto, Hermes starts with your main model for that job, so a premium reasoning model can end up doing routine support work too. You change it with hermes model, then configure auxiliary models, pick the task, and assign the provider and model you want. The rule he suggests is the right one - keep your strongest model where better reasoning matters, and move repetitive support jobs only when a cheaper or faster model genuinely fits that specific task.
https://x.com/HermesWatcher/status/2086935645319295276
A configuration detail that quietly doubles some people's bills, and almost nobody checks it. Most people think Hermes has one model decision; it really has two. Your main model runs the agent loop - the conversation, reasoning, tool calls and responses - but Hermes also has auxiliary model slots for side jobs like context compression, web extraction, vision, approvals, Skills Hub search, MCP helper work and session titles. The part worth checking is auto: when an auxiliary slot is set to auto, Hermes starts with your main model for that job, so a premium reasoning model can end up doing routine support work too. You change it with hermes model, then configure auxiliary models, pick the task, and assign the provider and model you want. The rule he suggests is the right one - keep your strongest model where better reasoning matters, and move repetitive support jobs only when a cheaper or faster model genuinely fits that specific task.
#49
@VietArchitectAI
https://x.com/VietArchitectAI/status/2086624951545786649
The enterprise requirements list nobody in the agent-loop discourse writes down, from someone leading an AI Agent Hub initiative at a Vietnamese bank. They are building a nine-layer GenAI capability landscape from Experience and Gateway down through Runtime for prompt, agent and orchestration, plus Knowledge, Model, MCP Tool Gateway, Data and Infra, with a strong cross-cutting governance, security and approval layer including human approval, maker-checker and risk tier. His questions are the useful part because they are what production in a regulated environment actually demands: how much of the runtime layer does a managed agent product cover, and critically, how does it support native pause and resume of the agent loop plus the ability to inject approval gates, given that human approval and response format are mandatory with maker-checker and multi-level approval. He also asks how mature the MCP implementation is with respect to permission scope, secrets and vault, idempotency, transaction limits and maker-checker.
https://x.com/VietArchitectAI/status/2086624951545786649
The enterprise requirements list nobody in the agent-loop discourse writes down, from someone leading an AI Agent Hub initiative at a Vietnamese bank. They are building a nine-layer GenAI capability landscape from Experience and Gateway down through Runtime for prompt, agent and orchestration, plus Knowledge, Model, MCP Tool Gateway, Data and Infra, with a strong cross-cutting governance, security and approval layer including human approval, maker-checker and risk tier. His questions are the useful part because they are what production in a regulated environment actually demands: how much of the runtime layer does a managed agent product cover, and critically, how does it support native pause and resume of the agent loop plus the ability to inject approval gates, given that human approval and response format are mandatory with maker-checker and multi-level approval. He also asks how mature the MCP implementation is with respect to permission scope, secrets and vault, idempotency, transaction limits and maker-checker.
#50
@echo_vic
https://x.com/echo_vic/status/2086608140833788352
The right frame for what happens at fleet scale, and the last clause is the one to remember. The 1,000-agent loop is where the fun ends and governance begins: at that scale you need per-agent permission scopes, a coordinator record that answers who did what, and verifiers that are not the agents themselves. Scale is a governance multiplier, not just a performance one. Verifiers that are not the agents themselves is the same requirement the protected-holdout point makes from the metrics side, arriving here from the accountability side.
https://x.com/echo_vic/status/2086608140833788352
The right frame for what happens at fleet scale, and the last clause is the one to remember. The 1,000-agent loop is where the fun ends and governance begins: at that scale you need per-agent permission scopes, a coordinator record that answers who did what, and verifiers that are not the agents themselves. Scale is a governance multiplier, not just a performance one. Verifiers that are not the agents themselves is the same requirement the protected-holdout point makes from the metrics side, arriving here from the accountability side.
#51
@AiCamila_
https://x.com/AiCamila_/status/2086856514854392194
Guardrails as a layered property of the loop rather than a filter at the end, which is the correct shape. A single filter is not enough; strong agent systems apply guardrails at multiple points - input, planning, tool use and output - so unsafe or low-quality behavior gets stopped early. Her cheatsheet: filter and sanitize inputs early, validate plans and tool choices before execution, score outputs for safety and quality, log every guardrail decision, and keep monitoring active across the full loop. The pro tip is the load-bearing line: guardrails that only sit at the end of the pipeline catch problems too late.
https://x.com/AiCamila_/status/2086856514854392194
Guardrails as a layered property of the loop rather than a filter at the end, which is the correct shape. A single filter is not enough; strong agent systems apply guardrails at multiple points - input, planning, tool use and output - so unsafe or low-quality behavior gets stopped early. Her cheatsheet: filter and sanitize inputs early, validate plans and tool choices before execution, score outputs for safety and quality, log every guardrail decision, and keep monitoring active across the full loop. The pro tip is the load-bearing line: guardrails that only sit at the end of the pipeline catch problems too late.
#52
@BotonomyAI
https://x.com/BotonomyAI/status/2086693959493927299
A failure that taught more than any tutorial, and it is worth reading as a cautionary spec. His first AI agent loop ran for 6 minutes, called itself recursively, and cost him $14. His claim is that this taught him more about agent architecture than any tutorial ever did, which is believable - recursive self-invocation with no depth limit and no budget ceiling is the single most common way a first loop ends, and it is also the cheapest possible version of the lesson.
https://x.com/BotonomyAI/status/2086693959493927299
A failure that taught more than any tutorial, and it is worth reading as a cautionary spec. His first AI agent loop ran for 6 minutes, called itself recursively, and cost him $14. His claim is that this taught him more about agent architecture than any tutorial ever did, which is believable - recursive self-invocation with no depth limit and no budget ceiling is the single most common way a first loop ends, and it is also the cheapest possible version of the lesson.
#53
@hlr_newsletter
https://x.com/hlr_newsletter/status/2086752620538995000
Why small implementations are pedagogically valuable, stated precisely. Pi from Scratch rebuilds a useful coding agent in about 600 lines of TypeScript: file tools, shell execution, traces and breakpoints. The reason it matters is the second sentence - small implementations help separate the essential agent loop from the reliability and security layers that production adds. Most people cannot tell which parts of their harness are the loop and which parts are scar tissue, and 600 lines is short enough to see the difference.
https://x.com/hlr_newsletter/status/2086752620538995000
Why small implementations are pedagogically valuable, stated precisely. Pi from Scratch rebuilds a useful coding agent in about 600 lines of TypeScript: file tools, shell execution, traces and breakpoints. The reason it matters is the second sentence - small implementations help separate the essential agent loop from the reliability and security layers that production adds. Most people cannot tell which parts of their harness are the loop and which parts are scar tissue, and 600 lines is short enough to see the difference.
#54
@Harnoor29581982
https://x.com/Harnoor29581982/status/2086657888345563586
A build-in-public agent runtime with an unusually production-shaped feature list. Pocket Agent Phase 3 is live, built with LangGraph and LangChain, and the choices worth noting are: create_agent plus middleware rather than a hand-rolled agent loop, 7 production-ready tools, persona loaded from a file with runtime context injection, human approval using interrupt() before irreversible actions, Postgres-backed calendar, memory and outbox, idempotent database schema initialization on startup, and tool failures handled gracefully without breaking the agent loop. Phase 4 is memory with a Postgres checkpointer, pgvector and retrieval gates. The interrupt-before-irreversible-actions pattern is exactly what the regulated-environment questions above are asking vendors for.
https://x.com/Harnoor29581982/status/2086657888345563586
A build-in-public agent runtime with an unusually production-shaped feature list. Pocket Agent Phase 3 is live, built with LangGraph and LangChain, and the choices worth noting are: create_agent plus middleware rather than a hand-rolled agent loop, 7 production-ready tools, persona loaded from a file with runtime context injection, human approval using interrupt() before irreversible actions, Postgres-backed calendar, memory and outbox, idempotent database schema initialization on startup, and tool failures handled gracefully without breaking the agent loop. Phase 4 is memory with a Postgres checkpointer, pgvector and retrieval gates. The interrupt-before-irreversible-actions pattern is exactly what the regulated-environment questions above are asking vendors for.
#55
@ChangHao564792d
https://x.com/ChangHao564792d/status/2086908133277147596
Two agent modes on one train-and-eval stack, and the second mode solves a real research problem. STACX supports Native Agent Mode, where you implement the agent loop directly in STACX for full token-level visibility, custom tools and fine-grained algorithm design. And Installed Agent Mode, where you run existing black-box scaffolds such as OpenHands and Terminus-2 directly inside task containers without rebuilding their agent loops - a recording proxy captures scaffold-to-LLM interactions and turns real agent trajectories into trainable data. Both modes support the full lifecycle of rollout, training, evaluation, and sandbox execution with verifier feedback. Turning an existing harness's real trajectories into training data without reimplementing the harness is the trick worth stealing here.
https://x.com/ChangHao564792d/status/2086908133277147596
Two agent modes on one train-and-eval stack, and the second mode solves a real research problem. STACX supports Native Agent Mode, where you implement the agent loop directly in STACX for full token-level visibility, custom tools and fine-grained algorithm design. And Installed Agent Mode, where you run existing black-box scaffolds such as OpenHands and Terminus-2 directly inside task containers without rebuilding their agent loops - a recording proxy captures scaffold-to-LLM interactions and turns real agent trajectories into trainable data. Both modes support the full lifecycle of rollout, training, evaluation, and sandbox execution with verifier feedback. Turning an existing harness's real trajectories into training data without reimplementing the harness is the trick worth stealing here.
#56
@Vtrivedy10
https://x.com/Vtrivedy10/status/2086853921549463875
A small observation about where verification is coming from now: the browser has become a default tool in running verification loops for self-improving agents. Deep Agents plus Stagehand v4 is the pairing he names, crediting the Browserbase team for making the abstractions and infrastructure easy to use. Worth putting next to the Figma-MCP entry - both are cases of a loop acquiring a verifier for a domain that used to have none, and in both cases the verifier is a rendered surface rather than a test suite.
https://x.com/Vtrivedy10/status/2086853921549463875
A small observation about where verification is coming from now: the browser has become a default tool in running verification loops for self-improving agents. Deep Agents plus Stagehand v4 is the pairing he names, crediting the Browserbase team for making the abstractions and infrastructure easy to use. Worth putting next to the Figma-MCP entry - both are cases of a loop acquiring a verifier for a domain that used to have none, and in both cases the verifier is a rendered surface rather than a test suite.
#57
@mehmed_bazdar
https://x.com/mehmed_bazdar/status/2086783271740768510
The cheapest way to build a harness for your own app, and it takes one sentence: if you need a good harness specific to your app, just point Claude or Codex at the Codex CLI, OpenCode or Pi repo and let it analyse the agent loop implementation. Three open reference implementations exist, they are readable, and the agent that will run inside your harness is also the best available reader of somebody else's.
https://x.com/mehmed_bazdar/status/2086783271740768510
The cheapest way to build a harness for your own app, and it takes one sentence: if you need a good harness specific to your app, just point Claude or Codex at the Codex CLI, OpenCode or Pi repo and let it analyse the agent loop implementation. Three open reference implementations exist, they are readable, and the agent that will run inside your harness is also the best available reader of somebody else's.
#58
@MBeekun
https://x.com/MBeekun/status/2086785886180491289
A vendor-independence process aimed at one specific constraint, prompted by DeepSeek announcing price increases and raising the question of how to avoid vendor lock-in. His article covers the model layer in LangChain, the process he follows when selecting providers without altering the agent loop, and - the useful part - why tool calls and structured output serve as the benchmark for evaluating a swap. Those two are the right test because they are where provider differences actually break things, while general answer quality is where people mistakenly look.
https://x.com/MBeekun/status/2086785886180491289
A vendor-independence process aimed at one specific constraint, prompted by DeepSeek announcing price increases and raising the question of how to avoid vendor lock-in. His article covers the model layer in LangChain, the process he follows when selecting providers without altering the agent loop, and - the useful part - why tool calls and structured output serve as the benchmark for evaluating a swap. Those two are the right test because they are where provider differences actually break things, while general answer quality is where people mistakenly look.
#59
@kamsakihiyuuma
https://x.com/kamsakihiyuuma/status/2086664903386108165
A second-order cost of agentic coding that deserves more attention than it gets. AI coding agents might create an unexpected problem: more code, less shared knowledge. If an engineer solves a problem through an AI agent, a lot of the reasoning can stay inside a private human-agent loop - no Stack Overflow answer, no GitHub discussion, no detailed issue thread, sometimes not even a meaningful commit message. His conclusion is the one to sit with: we may become dramatically better at producing software while becoming worse at producing the public knowledge future engineers learn from. Note that the models learning from that public knowledge are the same models closing the loop.
https://x.com/kamsakihiyuuma/status/2086664903386108165
A second-order cost of agentic coding that deserves more attention than it gets. AI coding agents might create an unexpected problem: more code, less shared knowledge. If an engineer solves a problem through an AI agent, a lot of the reasoning can stay inside a private human-agent loop - no Stack Overflow answer, no GitHub discussion, no detailed issue thread, sometimes not even a meaningful commit message. His conclusion is the one to sit with: we may become dramatically better at producing software while becoming worse at producing the public knowledge future engineers learn from. Note that the models learning from that public knowledge are the same models closing the loop.
#60
@VSMdev
https://x.com/VSMdev/status/2086929033129062441
The measurement that quantifies how far this has already gone, from a Microsoft production study. Copilot's agent loop is busy: 87% of LLM calls in the study were agent-initiated, with failures sometimes triggering dozens of retries. Both halves matter. Agent-initiated calls being the overwhelming majority means the human-typed prompt is now the minority case in production, and dozens of retries per failure is where the cost numbers elsewhere in this edition come from.
https://x.com/VSMdev/status/2086929033129062441
The measurement that quantifies how far this has already gone, from a Microsoft production study. Copilot's agent loop is busy: 87% of LLM calls in the study were agent-initiated, with failures sometimes triggering dozens of retries. Both halves matter. Agent-initiated calls being the overwhelming majority means the human-typed prompt is now the minority case in production, and dozens of retries per failure is where the cost numbers elsewhere in this edition come from.
#61
@alexchen77sh
https://x.com/alexchen77sh/status/2086933377018658836
A trending-repo readout with a thesis, and the thesis holds up against everything else in this edition: open source agents are moving beyond prompt wrappers toward persistent runtimes, structured context and complete workflows. Prime Agent sits at #1 with +2,362 stars in a day, where self-improvement and long-running coding tasks converge into agents designed as persistent systems. Semantica jumped from #35 to #7 with +906, as graph-native context and accountability gain ground over loosely connected retrieval. ComfyUI came from #29 to #8 with +871, node-based orchestration remaining a powerful interface for observable, reusable production workflows. And earendil-works/pi went #28 to #17 with +590, its unified model API, agent loop, TUI and coding CLI reflecting demand for complete, model-flexible toolchains. His final read: the question is no longer whether a model can perform a task, but whether the surrounding system can do it repeatedly, reliably and accountably.
https://x.com/alexchen77sh/status/2086933377018658836
A trending-repo readout with a thesis, and the thesis holds up against everything else in this edition: open source agents are moving beyond prompt wrappers toward persistent runtimes, structured context and complete workflows. Prime Agent sits at #1 with +2,362 stars in a day, where self-improvement and long-running coding tasks converge into agents designed as persistent systems. Semantica jumped from #35 to #7 with +906, as graph-native context and accountability gain ground over loosely connected retrieval. ComfyUI came from #29 to #8 with +871, node-based orchestration remaining a powerful interface for observable, reusable production workflows. And earendil-works/pi went #28 to #17 with +590, its unified model API, agent loop, TUI and coding CLI reflecting demand for complete, model-flexible toolchains. His final read: the question is no longer whether a model can perform a task, but whether the surrounding system can do it repeatedly, reliably and accountably.
#62
@CoreWeave
https://x.com/CoreWeave/status/2086928815872242034
A vendor pitch containing an argument worth taking seriously on its own terms. When everyone runs the same agent loop on the same frontier models, everyone converges on the same ceiling. Their proposal is to close the loop at the agent level first and then fine-tune the weights as well. Whether you buy their product or not, the premise is the one this entire edition keeps circling: shared harness plus shared model equals shared ceiling, and every differentiated result in this edition came from changing the loop rather than the model.
https://x.com/CoreWeave/status/2086928815872242034
A vendor pitch containing an argument worth taking seriously on its own terms. When everyone runs the same agent loop on the same frontier models, everyone converges on the same ceiling. Their proposal is to close the loop at the agent level first and then fine-tune the weights as well. Whether you buy their product or not, the premise is the one this entire edition keeps circling: shared harness plus shared model equals shared ceiling, and every differentiated result in this edition came from changing the loop rather than the model.
#63
@GuideboardLabs
https://x.com/GuideboardLabs/status/2086955371105599539
An agentic editing loop with vision in it, which is the part that makes it a loop. He gave Hermes Agent more than one clip from Seedance 2.5 for the first time and let it control the editing and stitching using CLI tools and built-in agent vision: four 14-second clips sliced and arranged to tell the story in the most cohesive way it saw fit. His conclusion is the general one - self-improving and evolving agents with a vision and purpose are bigger multipliers than most give them credit for, and anyone not actively building not only with agents but on the agents themselves is missing out.
https://x.com/GuideboardLabs/status/2086955371105599539
An agentic editing loop with vision in it, which is the part that makes it a loop. He gave Hermes Agent more than one clip from Seedance 2.5 for the first time and let it control the editing and stitching using CLI tools and built-in agent vision: four 14-second clips sliced and arranged to tell the story in the most cohesive way it saw fit. His conclusion is the general one - self-improving and evolving agents with a vision and purpose are bigger multipliers than most give them credit for, and anyone not actively building not only with agents but on the agents themselves is missing out.
#64
@TomasMann1878
https://x.com/TomasMann1878/status/2086865625201201419
Short, and the last three words are the point. He is shipping part of his self-improving agents article, with everything evaluated live rather than described - and he calls it RSI at home. Recursive self-improvement as a weekend project with a public eval endpoint is a very 2026 sentence, and it is the low-budget end of the same axis Discovery Loop just raised a company to work on.
https://x.com/TomasMann1878/status/2086865625201201419
Short, and the last three words are the point. He is shipping part of his self-improving agents article, with everything evaluated live rather than described - and he calls it RSI at home. Recursive self-improvement as a weekend project with a public eval endpoint is a very 2026 sentence, and it is the low-budget end of the same axis Discovery Loop just raised a company to work on.
#65
@divssvash
https://x.com/divssvash/status/2086903699100885311
Building one from scratch, with a checkpoint list that is a decent minimum spec. As of his checkpoint he has a working agent loop, a runtime environment, a toolkit, a parser for extraction, and a validator to not let it have access to his laptop. That last item is the one experienced people would flag as the important one, and he built it in without being told. His verdict: building from scratch is pretty cool actually, and more fun.
https://x.com/divssvash/status/2086903699100885311
Building one from scratch, with a checkpoint list that is a decent minimum spec. As of his checkpoint he has a working agent loop, a runtime environment, a toolkit, a parser for extraction, and a validator to not let it have access to his laptop. That last item is the one experienced people would flag as the important one, and he built it in without being told. His verdict: building from scratch is pretty cool actually, and more fun.
#66
@Swarna_Shikhar
https://x.com/Swarna_Shikhar/status/2086694241456234999
The minimum viable version, and the fact that it is local is what makes it interesting. He knew the theory of an AI agent but had never made one, so out of curiosity he built one. It works locally: Qwen2.5 7B through Ollama makes decisions about when to do a web search, read the page and respond - a typical agent loop. Read against the enterprise nine-layer landscape and the thousand-agent governance question elsewhere in this edition, the same loop fits in both a bank's architecture diagram and an afternoon of curiosity.
https://x.com/Swarna_Shikhar/status/2086694241456234999
The minimum viable version, and the fact that it is local is what makes it interesting. He knew the theory of an AI agent but had never made one, so out of curiosity he built one. It works locally: Qwen2.5 7B through Ollama makes decisions about when to do a web search, read the page and respond - a typical agent loop. Read against the enterprise nine-layer landscape and the thousand-agent governance question elsewhere in this edition, the same loop fits in both a bank's architecture diagram and an afternoon of curiosity.
#67
@AiApprenticeLab
https://x.com/AiApprenticeLab/status/2086952096977367491
A beginner's notes that name the loop's central tradeoff more clearly than most expert commentary. An agent can decide, act, observe, adjust, repeat, and that is what lets it solve multi-step problems. But every extra loop also creates another chance to misunderstand context, make a bad assumption, or slowly drift from the original goal. His notes cover how the agent loop actually works, why agents drift, how to keep them grounded, and better ways to prompt an agent for longer tasks. The framing that the same mechanism providing the capability also provides the failure mode is the honest way to describe this, and it is missing from most of the promotional material in this space.
https://x.com/AiApprenticeLab/status/2086952096977367491
A beginner's notes that name the loop's central tradeoff more clearly than most expert commentary. An agent can decide, act, observe, adjust, repeat, and that is what lets it solve multi-step problems. But every extra loop also creates another chance to misunderstand context, make a bad assumption, or slowly drift from the original goal. His notes cover how the agent loop actually works, why agents drift, how to keep them grounded, and better ways to prompt an agent for longer tasks. The framing that the same mechanism providing the capability also provides the failure mode is the honest way to describe this, and it is missing from most of the promotional material in this space.
#68
@VukRosic99
https://x.com/VukRosic99/status/2086687109214240919
An honest thinking-out-loud about how to fund the ambitious version, and the sequencing is smarter than it first sounds. He is considering building a company or product around autoresearch but applied to the algorithms and processes businesses already use - an auto hill climbing and auto optimization system pointed at economically useful processes that companies would pay for. Then use that money for the scientific auto discovery he wanted to do originally. Given that this edition contains a 9x speedup on production software and a 300x speedup on a test suite, the commercial half of that plan is already demonstrated.
https://x.com/VukRosic99/status/2086687109214240919
An honest thinking-out-loud about how to fund the ambitious version, and the sequencing is smarter than it first sounds. He is considering building a company or product around autoresearch but applied to the algorithms and processes businesses already use - an auto hill climbing and auto optimization system pointed at economically useful processes that companies would pay for. Then use that money for the scientific auto discovery he wanted to do originally. Given that this edition contains a 9x speedup on production software and a 300x speedup on a test suite, the commercial half of that plan is already demonstrated.
#69
@Yogin16
https://x.com/Yogin16/status/2086713134707073097
A one-line idea worth someone actually trying: if he had unlimited tokens, he would put a Karpathy-style autoresearch setup on docs and Excel to see whether there is a better version out there for docx or xlsx. Everything in this edition points autoresearch at code, kernels, model architectures and materials, all of which have obvious verifiers. Document and spreadsheet formats have decades of accumulated design decisions and, unusually, a testable objective in round-trip fidelity and parse speed - which makes the absence of anyone trying this the interesting part.
https://x.com/Yogin16/status/2086713134707073097
A one-line idea worth someone actually trying: if he had unlimited tokens, he would put a Karpathy-style autoresearch setup on docs and Excel to see whether there is a better version out there for docx or xlsx. Everything in this edition points autoresearch at code, kernels, model architectures and materials, all of which have obvious verifiers. Document and spreadsheet formats have decades of accumulated design decisions and, unusually, a testable objective in round-trip fidelity and parse speed - which makes the absence of anyone trying this the interesting part.
#70
@JackieLeeETH
https://x.com/JackieLeeETH/status/2086829280886198601
Infrastructure for the competition format, built because there is now enough of it to need tracking. He created a site to keep several auto-research contests in one place, with a global ranking based on best score placement weighted by the number of contest solvers. The weighting detail matters, since a first place in a contest with four entrants is not a first place in one with four hundred. His aside is a nice sign of the format working: he saw the same GitHub handles often enough that they became his contest friends.
https://x.com/JackieLeeETH/status/2086829280886198601
Infrastructure for the competition format, built because there is now enough of it to need tracking. He created a site to keep several auto-research contests in one place, with a global ranking based on best score placement weighted by the number of contest solvers. The weighting detail matters, since a first place in a contest with four entrants is not a first place in one with four hundred. His aside is a nice sign of the format working: he saw the same GitHub handles often enough that they became his contest friends.
#71
@varun_mathur
https://x.com/varun_mathur/status/2086650855185346986
A scale number for distributed experimentation that is hard to place anywhere else. They launched the gossiping agents protocol a few months ago, and agents on it have since done over 1 million public micro-experiments, gossiped with each other over a fully peer-to-peer network. Whatever the quality distribution of a million micro-experiments looks like, the architecture is the notable part - the leaderboard-based competitions elsewhere in this edition still route through a central verifier, and this does not.
https://x.com/varun_mathur/status/2086650855185346986
A scale number for distributed experimentation that is hard to place anywhere else. They launched the gossiping agents protocol a few months ago, and agents on it have since done over 1 million public micro-experiments, gossiped with each other over a fully peer-to-peer network. Whatever the quality distribution of a million micro-experiments looks like, the architecture is the notable part - the leaderboard-based competitions elsewhere in this edition still route through a central verifier, and this does not.
#72
@mdancho84
https://x.com/mdancho84/status/2086837008647733369
A framing aimed at practitioners deciding which side of a line to be on. Track 1 uses AI tools; Track 2 builds AI systems that replace workflows. AutoResearch is not another cool repo, it is a signal. Short, and slightly grandiose, but the distinction is the one the rest of this edition is a catalogue of - almost nobody in it is using a tool, and almost everybody in it is building a loop.
https://x.com/mdancho84/status/2086837008647733369
A framing aimed at practitioners deciding which side of a line to be on. Track 1 uses AI tools; Track 2 builds AI systems that replace workflows. AutoResearch is not another cool repo, it is a signal. Short, and slightly grandiose, but the distinction is the one the rest of this edition is a catalogue of - almost nobody in it is using a tool, and almost everybody in it is building a loop.
π‘ Eco Products Radar
Eco Products Radar
AutoResearch (Karpathy's setup) - the reference implementation almost every experiment in this edition extends or benchmarks against.
Pi - the minimalist harness appearing in cost comparisons, cron-replacement workflows, from-scratch tutorials and GitHub trending alike.
Codex - the harness people build around, port features from, and complain about missing scheduled tasks in.
Claude Code - the loop most autonomous runs are measured in, and the one whose per-hour burn rate keeps getting quoted.
Verifiers - not a product, but the component every framework, formula and failure report in this edition converges on.
eigenlabs competitions - the leaderboard-based autoresearch format now producing artifacts that may reach production.
Discovery Loop - Jeff Dean's new autoresearch startup, with Alphabet as founding investor.
MCP - the connection layer for multimodal plugins, parsers, browser verification and server sprawl warnings.
Hermes Agent - the harness whose auxiliary model slots turned out to be a quiet cost centre, also used for agentic video editing.
Ollama - how the local half of these loops actually runs, from 7B experiments to 30B agent models.
Muse Glimmer - Meta's 30B local agent model, notable here for completing a full local agent loop in its demo.
Prime Agent - number one on GitHub trending with +2,362 stars in a day, self-improvement plus long-running tasks.
LangGraph and LangChain - the runtime under the most production-shaped build-in-public agent this edition.
AutoResearch (Karpathy's setup) - the reference implementation almost every experiment in this edition extends or benchmarks against.
Pi - the minimalist harness appearing in cost comparisons, cron-replacement workflows, from-scratch tutorials and GitHub trending alike.
Codex - the harness people build around, port features from, and complain about missing scheduled tasks in.
Claude Code - the loop most autonomous runs are measured in, and the one whose per-hour burn rate keeps getting quoted.
Verifiers - not a product, but the component every framework, formula and failure report in this edition converges on.
eigenlabs competitions - the leaderboard-based autoresearch format now producing artifacts that may reach production.
Discovery Loop - Jeff Dean's new autoresearch startup, with Alphabet as founding investor.
MCP - the connection layer for multimodal plugins, parsers, browser verification and server sprawl warnings.
Hermes Agent - the harness whose auxiliary model slots turned out to be a quiet cost centre, also used for agentic video editing.
Ollama - how the local half of these loops actually runs, from 7B experiments to 30B agent models.
Muse Glimmer - Meta's 30B local agent model, notable here for completing a full local agent loop in its demo.
Prime Agent - number one on GitHub trending with +2,362 stars in a day, self-improvement plus long-running tasks.
LangGraph and LangChain - the runtime under the most production-shaped build-in-public agent this edition.
Comments