Loop Daily: July 25, 2026
Two things dominated the loop conversation today, and they point in opposite directions. The optimizer crowd shipped meta-tooling that mixes GEPA, AutoResearch and Meta-Harness into one pipeline, while a louder chorus kept hammering the same warning: the loop itself is trivial, the evaluator is the whole product. Underneath that, autoresearch kept walking out of the code repo entirely, into open math problems, security hunts, quant trading, and even GTA roleplay servers. And a hardware thread quietly redrew the line where a local model stops being a chatbot and starts holding an unattended agent loop.
#1
@idiom_bytes
https://x.com/idiom_bytes/status/2080367132320366843
Profiled the real token cost of two ways of running the same task. A predefined prompt on native Claude Code came out to about $0.37, the original agentic workflow burned 3.7M tokens (~$3.39), and an autoresearch-style run cut that to 2.09M tokens (~$1.94). The point isn't the price, it's that these are different products: a prompt buys you an output, a pipeline buys you a governed, auditable, self-improving system. The open question he lands on is task classification, knowing which job actually needs the heavy loop.
https://x.com/idiom_bytes/status/2080367132320366843
Profiled the real token cost of two ways of running the same task. A predefined prompt on native Claude Code came out to about $0.37, the original agentic workflow burned 3.7M tokens (~$3.39), and an autoresearch-style run cut that to 2.09M tokens (~$1.94). The point isn't the price, it's that these are different products: a prompt buys you an output, a pipeline buys you a governed, auditable, self-improving system. The open question he lands on is task classification, knowing which job actually needs the heavy loop.
#2
@usr_bin_roygbiv
https://x.com/usr_bin_roygbiv/status/2080098090757894263
Ran Sol on max autoresearch pointed at real open-source projects and got actual merges this week, on optimizations and bugs it found completely AFK. This is the escaped-code version of the loop: not a benchmark, real PRs landing in real repos with zero human in the seat. The signal everyone keeps missing is that unattended only works when there's an unambiguous accept signal, and a passing test suite is exactly that.
https://x.com/usr_bin_roygbiv/status/2080098090757894263
Ran Sol on max autoresearch pointed at real open-source projects and got actual merges this week, on optimizations and bugs it found completely AFK. This is the escaped-code version of the loop: not a benchmark, real PRs landing in real repos with zero human in the seat. The signal everyone keeps missing is that unattended only works when there's an unambiguous accept signal, and a passing test suite is exactly that.
#3
@oilersbluesky
https://x.com/oilersbluesky/status/2080125189463904560
Has been running Karpathy-style auto research loops with Sol and Fable, with one clever constraint: an experiment only counts as a win if it's both faster AND uses less memory, so the agent can't cheat by trading memory for speed with caches. Under that dual gate it routinely produced code 20% faster using 20% less memory. It's a tiny reward-design trick that quietly kills the most common way these loops game their own metric.
https://x.com/oilersbluesky/status/2080125189463904560
Has been running Karpathy-style auto research loops with Sol and Fable, with one clever constraint: an experiment only counts as a win if it's both faster AND uses less memory, so the agent can't cheat by trading memory for speed with caches. Under that dual gate it routinely produced code 20% faster using 20% less memory. It's a tiny reward-design trick that quietly kills the most common way these loops game their own metric.
#4
@whp_wessel
https://x.com/whp_wessel/status/2080361108079026570
Turned another user's workflow into an ErdΕs autoresearch skill you can point at an open ErdΕs problem and let run overnight. This is the "one script, one GPU, one night" pattern applied to unsolved math instead of code, and it's becoming a genre. The bottleneck is no longer the loop, it's picking a problem where success is checkable.
https://x.com/whp_wessel/status/2080361108079026570
Turned another user's workflow into an ErdΕs autoresearch skill you can point at an open ErdΕs problem and let run overnight. This is the "one script, one GPU, one night" pattern applied to unsolved math instead of code, and it's becoming a genre. The bottleneck is no longer the loop, it's picking a problem where success is checkable.
#5
@ChengleiSi
https://x.com/ChengleiSi/status/2080323799808168070
Made the sharpest methodology argument of the day: research is about discovering insights, not blindly optimizing a metric, so autoresearch should expose full training dynamics and diagnostics to the agent rather than a single val-loss number. His example is having the agent look at MoE load balancing instead of just loss. The framing that matters is understanding-maxxing over bench-maxxing, on the bet that those insights transfer while bench tricks don't.
https://x.com/ChengleiSi/status/2080323799808168070
Made the sharpest methodology argument of the day: research is about discovering insights, not blindly optimizing a metric, so autoresearch should expose full training dynamics and diagnostics to the agent rather than a single val-loss number. His example is having the agent look at MoE load balancing instead of just loss. The framing that matters is understanding-maxxing over bench-maxxing, on the bet that those insights transfer while bench tricks don't.
#6
@ShangyinT
https://x.com/ShangyinT/status/2080334990060183960
Ran a real head-to-head of AutoResearch, Meta-Harness and GEPA on Frontier-CS at matched model, thinking effort and budget. The finding is that no single optimizer dominates: across 10 tasks, GEPA won 3, AutoResearch won 3, and Meta-Harness won 4. That's the empirical case for a meta-optimizer, and a useful reality check against anyone claiming one loop architecture wins everywhere.
https://x.com/ShangyinT/status/2080334990060183960
Ran a real head-to-head of AutoResearch, Meta-Harness and GEPA on Frontier-CS at matched model, thinking effort and budget. The finding is that no single optimizer dominates: across 10 tasks, GEPA won 3, AutoResearch won 3, and Meta-Harness won 4. That's the empirical case for a meta-optimizer, and a useful reality check against anyone claiming one loop architecture wins everywhere.
#7
@JoshDarwin8
https://x.com/JoshDarwin8/status/2080284413233910185
Laid out a cost-collapsing stack he's actually running: frontier models for planning and design, AutoResearch for validation and eval, and local models for the execution loops. His claim is this combination gets you close to free frontier performance, with Qwen carrying the local side. It's a concrete example of the model-portability play everyone's theorizing about.
https://x.com/JoshDarwin8/status/2080284413233910185
Laid out a cost-collapsing stack he's actually running: frontier models for planning and design, AutoResearch for validation and eval, and local models for the execution loops. His claim is this combination gets you close to free frontier performance, with Qwen carrying the local side. It's a concrete example of the model-portability play everyone's theorizing about.
#8
@SasuRobert
https://x.com/SasuRobert/status/2080250603003924630
Named the hardest practical problem in running autoresearch: keeping the loop focused on the actual experiment. The wider the problem, the easier it is for the LLM to take shortcuts, so getting the task into the proper form and direction is most of the work. It's a quiet counterweight to the hype, from someone clearly running these loops in anger rather than admiring them.
https://x.com/SasuRobert/status/2080250603003924630
Named the hardest practical problem in running autoresearch: keeping the loop focused on the actual experiment. The wider the problem, the easier it is for the LLM to take shortcuts, so getting the task into the proper form and direction is most of the work. It's a quiet counterweight to the hype, from someone clearly running these loops in anger rather than admiring them.
#9
@ZimingLiu11
https://x.com/ZimingLiu11/status/2080196540799549570
Proposed "Mechanistic Auto-Research" that uses no LLMs at all yet claims to surpass RSI's results, with the tagline scale insight, not compute. The provocation is direct: today's auto-research is Shakespeare's monkeys typing randomly and hoping brilliance falls out, and there may be a more principled path. Whether it holds up or not, it's a real attack on the brute-force framing of the whole category.
https://x.com/ZimingLiu11/status/2080196540799549570
Proposed "Mechanistic Auto-Research" that uses no LLMs at all yet claims to surpass RSI's results, with the tagline scale insight, not compute. The provocation is direct: today's auto-research is Shakespeare's monkeys typing randomly and hoping brilliance falls out, and there may be a more principled path. Whether it holds up or not, it's a real attack on the brute-force framing of the whole category.
#10
@Dinosn
https://x.com/Dinosn/status/2080168279419601311
Pointed an auto-research security hunt (RAPTOR) at Apache Axis 1.x and Axis2 and came back with lab-proven unauthenticated RCE on both targets. This is autoresearch as an offensive-security loop: the agent grinds the attack surface and the accept signal is a working exploit. It's one of the cleaner non-coding applications of the pattern this week.
https://x.com/Dinosn/status/2080168279419601311
Pointed an auto-research security hunt (RAPTOR) at Apache Axis 1.x and Axis2 and came back with lab-proven unauthenticated RCE on both targets. This is autoresearch as an offensive-security loop: the agent grinds the attack surface and the accept signal is a working exploit. It's one of the cleaner non-coding applications of the pattern this week.
#11
@jehillparikh
https://x.com/jehillparikh/status/2080354879730811270
Built an auto-research agent on top of what he calls the Zeta Law, with a second agent that automatically updates their encoder registry as new foundation models emerge and generates PyTorch fine-tune scripts for a given task. Auto-distillation is the work-in-progress piece. It's a nice example of a loop that maintains its own infrastructure, not just runs experiments.
https://x.com/jehillparikh/status/2080354879730811270
Built an auto-research agent on top of what he calls the Zeta Law, with a second agent that automatically updates their encoder registry as new foundation models emerge and generates PyTorch fine-tune scripts for a given task. Auto-distillation is the work-in-progress piece. It's a nice example of a loop that maintains its own infrastructure, not just runs experiments.
#12
@madhukarkumar
https://x.com/madhukarkumar/status/2080341938805539230
Announced self-improving websites: an auto-research loop for a site, but with a human holding final discretion. You set a goal, agents measure and suggest changes, and each week you review, approve or apply, then iterate. It's the pragmatic middle path between a fully unattended loop and manual optimization, and it fits the "measurable metric plus editable artifact" recipe exactly.
https://x.com/madhukarkumar/status/2080341938805539230
Announced self-improving websites: an auto-research loop for a site, but with a human holding final discretion. You set a goal, agents measure and suggest changes, and each week you review, approve or apply, then iterate. It's the pragmatic middle path between a fully unattended loop and manual optimization, and it fits the "measurable metric plus editable artifact" recipe exactly.
#13
@willm4rgs
https://x.com/willm4rgs/status/2080107814177972246
Ran an auto research setup with GPT-5.6 ultra to build part of a model and, for the first time, it didn't spout nonsense: given the context, it figured out to solve using a pseudoinverse rather than training with backprop. Small anecdote, big signal, the loop found a genuinely better method rather than grinding the obvious one. That's the moment autoresearch stops being search and starts looking like reasoning.
https://x.com/willm4rgs/status/2080107814177972246
Ran an auto research setup with GPT-5.6 ultra to build part of a model and, for the first time, it didn't spout nonsense: given the context, it figured out to solve using a pseudoinverse rather than training with backprop. Small anecdote, big signal, the loop found a genuinely better method rather than grinding the obvious one. That's the moment autoresearch stops being search and starts looking like reasoning.
#14
@dosco
https://x.com/dosco/status/2080368015988687268
Broke down the different optimizers while building them into the ax framework: GEPA does reflection, mutation and Pareto selection; auto-research owns the entire experiment loop; meta-harness proposes one change at a time; omni keeps the best result for the next round. Vibing them into ax was how he figured out what each actually is and where the gaps in his own framework were. It's the clearest one-line taxonomy of the current optimizer zoo.
https://x.com/dosco/status/2080368015988687268
Broke down the different optimizers while building them into the ax framework: GEPA does reflection, mutation and Pareto selection; auto-research owns the entire experiment loop; meta-harness proposes one change at a time; omni keeps the best result for the next round. Vibing them into ax was how he figured out what each actually is and where the gaps in his own framework were. It's the clearest one-line taxonomy of the current optimizer zoo.
#15
@neil_xbt
https://x.com/neil_xbt/status/2080144372486807577
Published the actual six-module agent loop behind "quantum trading," with the honest disclaimer that almost none of it is literally quantum. Perception ingests order book and funding data, a state encoder turns signals into a quantum-style state where they can reinforce or cancel, a Hamiltonian encodes the risk/return objective, a solver finds the lowest-energy portfolio via simulated annealing, measurement collapses into positions, and execution updates tomorrow's priors. The genuine edge he claims is portfolio optimization at scale and signal interference, not magic.
https://x.com/neil_xbt/status/2080144372486807577
Published the actual six-module agent loop behind "quantum trading," with the honest disclaimer that almost none of it is literally quantum. Perception ingests order book and funding data, a state encoder turns signals into a quantum-style state where they can reinforce or cancel, a Hamiltonian encodes the risk/return objective, a solver finds the lowest-energy portfolio via simulated annealing, measurement collapses into positions, and execution updates tomorrow's priors. The genuine edge he claims is portfolio optimization at scale and signal interference, not magic.
#16
@sudoingX
https://x.com/sudoingX/status/2080363228660719628
Benched local models by hardware tier on his own machines specifically for holding an agent loop. The headline: Bonsai 27B, a 1-bit crush of Qwen 3.6 27B down to 3.9GB, runs the full agent loop at 128k context on an 8GB laptop GPU, while a DGX Spark holds Laguna S 2.1 at 30-45 tok/s across a 128k window. Every number is self-measured, which is exactly the receipt these local-agent claims usually lack.
https://x.com/sudoingX/status/2080363228660719628
Benched local models by hardware tier on his own machines specifically for holding an agent loop. The headline: Bonsai 27B, a 1-bit crush of Qwen 3.6 27B down to 3.9GB, runs the full agent loop at 128k context on an 8GB laptop GPU, while a DGX Spark holds Laguna S 2.1 at 30-45 tok/s across a 128k window. Every number is self-measured, which is exactly the receipt these local-agent claims usually lack.
#17
@amasad
https://x.com/amasad/status/2080371567221944657
Told the story of Viktor, who disrupted the agency model with Replit and then asked why not automate the whole thing, not just the coding. The insight is that the agency is merely an agent loop, so he asked for an MCP, Replit built one, and he now runs an autonomous agency on it. It's a clean case of the loop swallowing the entire business process, not just the dev step.
https://x.com/amasad/status/2080371567221944657
Told the story of Viktor, who disrupted the agency model with Replit and then asked why not automate the whole thing, not just the coding. The insight is that the agency is merely an agent loop, so he asked for an MCP, Replit built one, and he now runs an autonomous agency on it. It's a clean case of the loop swallowing the entire business process, not just the dev step.
#18
@0xbelorix
https://x.com/0xbelorix/status/2080377293516542137
Made the sharpest non-coding loop case of the day: a NoPixel-style GTA roleplay server that used to need a full scripting team can now be run by one operator with an agent loop and under $100 of subscriptions. The operator writes character arcs and mission scripts through Claude, voices NPCs by cloning through ElevenLabs, and renders cutscene avatars through HeyGen, all in one iteration loop. With GTA 6 landing in November, that's a live-content studio collapsed into one person's afternoon.
https://x.com/0xbelorix/status/2080377293516542137
Made the sharpest non-coding loop case of the day: a NoPixel-style GTA roleplay server that used to need a full scripting team can now be run by one operator with an agent loop and under $100 of subscriptions. The operator writes character arcs and mission scripts through Claude, voices NPCs by cloning through ElevenLabs, and renders cutscene avatars through HeyGen, all in one iteration loop. With GTA 6 landing in November, that's a live-content studio collapsed into one person's afternoon.
#19
@MikeMatchpoint
https://x.com/MikeMatchpoint/status/2080300007563960660
Reported a real self-improving harness failure: the orchestration over-indexed on adding validation steps, which added friction to every task and bottlenecked throughput. The fix was almost funny in its simplicity, swap the success criteria being benchmarked to prioritize throughput rather than introduced errors. His takeaway is that past a threshold it's faster to let the agent fix benign errors than to optimize to prevent them, which is a genuinely non-obvious operating lesson.
https://x.com/MikeMatchpoint/status/2080300007563960660
Reported a real self-improving harness failure: the orchestration over-indexed on adding validation steps, which added friction to every task and bottlenecked throughput. The fix was almost funny in its simplicity, swap the success criteria being benchmarked to prioritize throughput rather than introduced errors. His takeaway is that past a threshold it's faster to let the agent fix benign errors than to optimize to prevent them, which is a genuinely non-obvious operating lesson.
#20
@heizolshao
https://x.com/heizolshao/status/2080214381682430402
Pushed back on the multi-agent hype from real experience: with today's models you often don't need many agents handing off to each other, because a single stronger model running with tools and memory in a continuous loop is simpler and more stable. He's found the coordination cost of multi-agent systems higher than expected. It's a useful dissent in a week where "graphs beat loops" was the loud take.
https://x.com/heizolshao/status/2080214381682430402
Pushed back on the multi-agent hype from real experience: with today's models you often don't need many agents handing off to each other, because a single stronger model running with tools and memory in a continuous loop is simpler and more stable. He's found the coordination cost of multi-agent systems higher than expected. It's a useful dissent in a week where "graphs beat loops" was the loud take.
#21
@arymukti04
https://x.com/arymukti04/status/2080229800489488686
Laid out the most disciplined improvement-loop architecture of the day: four separated roles, a Proposer that turns failure traces into narrow changes, an Evaluator on a frozen benchmark the proposer can't rewrite, a Judge computing machine-verifiable metrics, and a Promoter that gates, signs, canaries and keeps a rollback path. The key data structure isn't memory, it's an experiment record with baseline, candidate, dataset hash, metrics and rollback reason. His rule: agents propose evolution, but deterministic gates control inheritance.
https://x.com/arymukti04/status/2080229800489488686
Laid out the most disciplined improvement-loop architecture of the day: four separated roles, a Proposer that turns failure traces into narrow changes, an Evaluator on a frozen benchmark the proposer can't rewrite, a Judge computing machine-verifiable metrics, and a Promoter that gates, signs, canaries and keeps a rollback path. The key data structure isn't memory, it's an experiment record with baseline, candidate, dataset hash, metrics and rollback reason. His rule: agents propose evolution, but deterministic gates control inheritance.
#22
@PeerReview
https://x.com/PeerReview/status/2080374363530912045
Actually measured what a self-improving skill does instead of asserting it: they gave the Hermes Agent web-search skills with a self-improving plugin, then ran the loop with a judge grading against gold answers and a reflection agent rewriting the skill from its own failures. Three cycles took the research skill from 0.38 to 0.49 mean answer F1, a 29% relative gain, at a flat tool budget. The line worth keeping is that a self-improving skill without an eval is just a gut feeling.
https://x.com/PeerReview/status/2080374363530912045
Actually measured what a self-improving skill does instead of asserting it: they gave the Hermes Agent web-search skills with a self-improving plugin, then ran the loop with a judge grading against gold answers and a reflection agent rewriting the skill from its own failures. Three cycles took the research skill from 0.38 to 0.49 mean answer F1, a 29% relative gain, at a flat tool budget. The line worth keeping is that a self-improving skill without an eval is just a gut feeling.
#23
@lagerskoy
https://x.com/lagerskoy/status/2080261151120904278
Recapped a Jeff Clune talk that's the deepest thing on loops this week. VPT reached a Minecraft diamond pickaxe because the game hands you an unambiguous reward, but every problem worth solving withholds one, and the Achilles heel of open-endedness is being unable to quantify which tasks are actually interesting. Clune's fix is to stop hand-coding "interesting" and query a foundation model as the arbiter instead. The punchline: more iterations and compute don't raise the ceiling, the metric is the ceiling, and most people building loops never wrote down what they're scoring.
https://x.com/lagerskoy/status/2080261151120904278
Recapped a Jeff Clune talk that's the deepest thing on loops this week. VPT reached a Minecraft diamond pickaxe because the game hands you an unambiguous reward, but every problem worth solving withholds one, and the Achilles heel of open-endedness is being unable to quantify which tasks are actually interesting. Clune's fix is to stop hand-coding "interesting" and query a foundation model as the arbiter instead. The punchline: more iterations and compute don't raise the ceiling, the metric is the ceiling, and most people building loops never wrote down what they're scoring.
#24
@kobaHUB
https://x.com/kobaHUB/status/2080237903855145262
Connected today's viral generate-evaluate-reflect-mutate loops back to Richard Sutton's bitter lesson: general methods that leverage raw computation beat hand-engineered human knowledge every time, short-term losses and all. The loops going viral now are the bitter lesson in production, a dumb honest process that scales with compute and doesn't get tired. It's a good frame for why the simplest loop plus a real signal keeps beating clever architectures.
https://x.com/kobaHUB/status/2080237903855145262
Connected today's viral generate-evaluate-reflect-mutate loops back to Richard Sutton's bitter lesson: general methods that leverage raw computation beat hand-engineered human knowledge every time, short-term losses and all. The loops going viral now are the bitter lesson in production, a dumb honest process that scales with compute and doesn't get tired. It's a good frame for why the simplest loop plus a real signal keeps beating clever architectures.
#25
@Frandeeer
https://x.com/Frandeeer/status/2080275230912602557
Reached back to Norbert Wiener's 1948 cybernetics to make the same point everyone's circling: intelligence needs feedback, but feedback only works when the signal represents reality. Reward test coverage and the agent writes useless tests, reward a judge model and it learns the judge's preferences instead of the task. Generate, evaluate, reflect, mutate is the difference between retrying and improving, and the expensive skill is designing the metric the system cannot cheat.
https://x.com/Frandeeer/status/2080275230912602557
Reached back to Norbert Wiener's 1948 cybernetics to make the same point everyone's circling: intelligence needs feedback, but feedback only works when the signal represents reality. Reward test coverage and the agent writes useless tests, reward a judge model and it learns the judge's preferences instead of the task. Generate, evaluate, reflect, mutate is the difference between retrying and improving, and the expensive skill is designing the metric the system cannot cheat.
#26
@omarsar0
https://x.com/omarsar0/status/2080296884187652381
Flagged the Harness Handbook paper, which is a concrete tool for the self-improving-harness problem: it builds a three-level map from runtime behaviors to source locations so a coding agent can find every file behind one behavior before editing. Across 60 modification requests on Codex and Terminus-2, handbook guidance raised planning win rates from 28.3% to 38.3% and from 26.7% to 45.6%, while cutting planner tokens. The interesting bit is it directly attacks the localization problem that makes large agent harnesses hard to evolve.
https://x.com/omarsar0/status/2080296884187652381
Flagged the Harness Handbook paper, which is a concrete tool for the self-improving-harness problem: it builds a three-level map from runtime behaviors to source locations so a coding agent can find every file behind one behavior before editing. Across 60 modification requests on Codex and Terminus-2, handbook guidance raised planning win rates from 28.3% to 38.3% and from 26.7% to 45.6%, while cutting planner tokens. The interesting bit is it directly attacks the localization problem that makes large agent harnesses hard to evolve.
#27
@mrinal
https://x.com/mrinal/status/2080149284595572820
Shared hard-won experience from Fluent, his open-source self-improving software factory, on the real problem of swarm convergence. Parallelizable problems are trivial, each agent maps a simple independent goal and you aggregate, but complex convergence is fascinating and easy to end up in never-ending loops. His half-joke that sometimes an infinite loop is maybe okay is exactly the kind of thing you only learn by running these systems past the demo stage.
https://x.com/mrinal/status/2080149284595572820
Shared hard-won experience from Fluent, his open-source self-improving software factory, on the real problem of swarm convergence. Parallelizable problems are trivial, each agent maps a simple independent goal and you aggregate, but complex convergence is fascinating and easy to end up in never-ending loops. His half-joke that sometimes an infinite loop is maybe okay is exactly the kind of thing you only learn by running these systems past the demo stage.
#28
@keydunov
https://x.com/keydunov/status/2080324099868602834
Described how his personal workflow changed more in 12 months than the previous 12 years: Claude and Codex are wired into GitHub, DNS and CRM, and he no longer touches those objects, he asks the agent to change state and report back. On that thesis they shipped a Cube CLI covering the entire public API, so a single Claude Code prompt goes from a Postgres database to a deployed data model and a working React dashboard. The bet is that every action gets driven by agents, whether a human instructs them or a self-improving recursive loop does.
https://x.com/keydunov/status/2080324099868602834
Described how his personal workflow changed more in 12 months than the previous 12 years: Claude and Codex are wired into GitHub, DNS and CRM, and he no longer touches those objects, he asks the agent to change state and report back. On that thesis they shipped a Cube CLI covering the entire public API, so a single Claude Code prompt goes from a Postgres database to a deployed data model and a working React dashboard. The bet is that every action gets driven by agents, whether a human instructs them or a self-improving recursive loop does.
π‘ Eco Products Radar
Eco Products Radar
GEPA β LLM optimizer (reflection, mutation, Pareto selection), now bundled into the optimize_anything omni meta-optimizer alongside AutoResearch and Meta-Harness.
AutoResearch / Meta-Harness β the two other program.md-style optimizers repeatedly benchmarked head-to-head this week; no single one dominates across tasks.
Hermes Agent β the self-improving-skill harness behind the measured +29% F1 research-skill result.
Claude Code / Codex β the coding agents most cited as the execution layer for agentic and self-improving loops.
Local model stack (Bonsai 27B, Qwen 3.6, Laguna S 2.1) β the hardware-tiered local models people are actually holding agent loops on.
GEPA β LLM optimizer (reflection, mutation, Pareto selection), now bundled into the optimize_anything omni meta-optimizer alongside AutoResearch and Meta-Harness.
AutoResearch / Meta-Harness β the two other program.md-style optimizers repeatedly benchmarked head-to-head this week; no single one dominates across tasks.
Hermes Agent β the self-improving-skill harness behind the measured +29% F1 research-skill result.
Claude Code / Codex β the coding agents most cited as the execution layer for agentic and self-improving loops.
Local model stack (Bonsai 27B, Qwen 3.6, Laguna S 2.1) β the hardware-tiered local models people are actually holding agent loops on.
Comments