Loop Daily: July 10, 2026
Harness engineering was the loudest signal today. The idea keeps hardening: once models get good enough at following instructions and exploring solutions, the bottleneck stops being the model and becomes the scaffolding around it β the loop, the evals, the memory, the permissions. That framing drove the day, and underneath it sat the receipts: a 212x kernel speedup from autoresearch, a home leaderboard entry scored overnight on a single H100, a local rig quietly training itself off its own work logs. The other half of the conversation was about money β everyone suddenly measuring an agent loop not by how smart it is but by whether it survives the invoice.
#1
@dejavucoder
https://x.com/dejavucoder/status/2074912810803560497
The strongest autoresearch case of the day. He ran an auto-research loop with Codex on GPU Mode's qr_v2 problem and landed a 212x faster kernel over baseline on the QR decomposition. This is the whole autoresearch thesis in one artifact: point a coding agent at a measurable target, let it search, and it finds optimizations a human would take weeks to hand-tune. 345 likes and 22k views because the number is real and reproducible, not a vibe.
https://x.com/dejavucoder/status/2074912810803560497
The strongest autoresearch case of the day. He ran an auto-research loop with Codex on GPU Mode's qr_v2 problem and landed a 212x faster kernel over baseline on the QR decomposition. This is the whole autoresearch thesis in one artifact: point a coding agent at a measurable target, let it search, and it finds optimizations a human would take weeks to hand-tune. 345 likes and 22k views because the number is real and reproducible, not a vibe.
#2
@aiDotEngineer
https://x.com/aiDotEngineer/status/2074649873597771835
Best mental model of the day. They ran autoresearch on preprocessing for a fraud-detection task, and with a loose API the score looked great β because the code was leaking test data into the features in 13 different ways. Tightening the abstraction to a strict API dropped the reward-hacking rate to zero. His metaphor: doing autoresearch is like training a model, where the codebase abstraction is the architecture that biases everything the search can find, and the eval is the loss function. The human job is no longer writing exact code, it's getting the constraints and feedback signal right.
https://x.com/aiDotEngineer/status/2074649873597771835
Best mental model of the day. They ran autoresearch on preprocessing for a fraud-detection task, and with a loose API the score looked great β because the code was leaking test data into the features in 13 different ways. Tightening the abstraction to a strict API dropped the reward-hacking rate to zero. His metaphor: doing autoresearch is like training a model, where the codebase abstraction is the architecture that biases everything the search can find, and the eval is the loss function. The human job is no longer writing exact code, it's getting the constraints and feedback signal right.
#3
@raymogg
https://x.com/raymogg/status/2074661122003886532
Concrete overnight autoresearch result. Inspired by Recursive_SI, he built a custom harness to explore Karpathy's autoresearch problem, and from 250 minutes on an initial seed with one H100 scored 0.985924 bpb β enough to sit at position 29 on the autoresearch-at-home leaderboard in very little run time. This is the "one script, one GPU, one night" story made literal, and he says he has more ideas to test and open-source. The barrier to running real research loops keeps dropping.
https://x.com/raymogg/status/2074661122003886532
Concrete overnight autoresearch result. Inspired by Recursive_SI, he built a custom harness to explore Karpathy's autoresearch problem, and from 250 minutes on an initial seed with one H100 scored 0.985924 bpb β enough to sit at position 29 on the autoresearch-at-home leaderboard in very little run time. This is the "one script, one GPU, one night" story made literal, and he says he has more ideas to test and open-source. The barrier to running real research loops keeps dropping.
#4
@SOntheotherside
https://x.com/SOntheotherside/status/2074790147040723175
The most ambitious local setup posted today. An AMD Ryzen AI Max+ 395 box with 128GB unified memory running a full local inference stack β Qwen, DeepSeek V4 Flash, MiniMax M3 via SSD streaming β as the execution node for a multi-node system. The real point is an 8-phase fine-tuning pipeline that extracts training pairs from the agent's own worklogs, trains LoRA adapters, benchmarks them against cloud APIs, and promotes the winners. A self-improving local AI that learns from its own work and progressively replaces cloud calls. This is autoresearch pointed at cost.
https://x.com/SOntheotherside/status/2074790147040723175
The most ambitious local setup posted today. An AMD Ryzen AI Max+ 395 box with 128GB unified memory running a full local inference stack β Qwen, DeepSeek V4 Flash, MiniMax M3 via SSD streaming β as the execution node for a multi-node system. The real point is an 8-phase fine-tuning pipeline that extracts training pairs from the agent's own worklogs, trains LoRA adapters, benchmarks them against cloud APIs, and promotes the winners. A self-improving local AI that learns from its own work and progressively replaces cloud calls. This is autoresearch pointed at cost.
#5
@WhinyPuppy98
https://x.com/WhinyPuppy98/status/2074891396360663306
The harness-versus-harness benchmark almost nobody runs. Testing local open-weight models across Qwen-Code, Codex, and Claude Code, he found Claude Code burns roughly 2x more tokens than Codex for the same task β same model, same prompt, different wrapper, double the cost. Big enough to flip your model economics: you might pick a cheaper model and lose the savings to harness overhead. His other finding: 30B MoE models now run at ~40 tok/sec on a Mac, comfortably in daily-driver territory. The bottleneck moved from model capability to harness efficiency.
https://x.com/WhinyPuppy98/status/2074891396360663306
The harness-versus-harness benchmark almost nobody runs. Testing local open-weight models across Qwen-Code, Codex, and Claude Code, he found Claude Code burns roughly 2x more tokens than Codex for the same task β same model, same prompt, different wrapper, double the cost. Big enough to flip your model economics: you might pick a cheaper model and lose the savings to harness overhead. His other finding: 30B MoE models now run at ~40 tok/sec on a Mac, comfortably in daily-driver territory. The bottleneck moved from model capability to harness efficiency.
#6
@corentinanjuna
https://x.com/corentinanjuna/status/2074856712465719453
A wild throughput number. Their LLMD agentic loop runs in under a minute for a combined transitive source set of more than 100M lines of code across dependencies, targeting 5 different chips. That means you can turn an agent loose on the whole stack and test changes for all chips at once in under a minute. When the loop is that fast, the entire economics of "let the agent try things" changes β iteration cost collapses toward zero.
https://x.com/corentinanjuna/status/2074856712465719453
A wild throughput number. Their LLMD agentic loop runs in under a minute for a combined transitive source set of more than 100M lines of code across dependencies, targeting 5 different chips. That means you can turn an agent loose on the whole stack and test changes for all chips at once in under a minute. When the loop is that fast, the entire economics of "let the agent try things" changes β iteration cost collapses toward zero.
#7
@dipankarsarkar
https://x.com/dipankarsarkar/status/2074890187394416774
A sharp reminder that the glue matters more than the hardware. He profiled a local agent loop expecting bandwidth to be the wall β it was deepcopy on the state object between steps. Swapping the serialization path got ~30x, hardware untouched. His line lands: a lot of the spec sheet leaks out in the glue before decode even runs. Most agent-loop slowness isn't the model, it's the plumbing around it.
https://x.com/dipankarsarkar/status/2074890187394416774
A sharp reminder that the glue matters more than the hardware. He profiled a local agent loop expecting bandwidth to be the wall β it was deepcopy on the state object between steps. Swapping the serialization path got ~30x, hardware untouched. His line lands: a lot of the spec sheet leaks out in the glue before decode even runs. Most agent-loop slowness isn't the model, it's the plumbing around it.
#8
@albertgao
https://x.com/albertgao/status/2074798672546508944
The hidden tax of multi-model agent loops: prompt caches expire. In a code-review-fix loop, if the programmer sub-agent takes too long to implement a fix, the reviewer's cache has already expired by the time it's called back, so it starts from zero β and the loop can repeat N times if the reviewer keeps flagging false alarms. This is the unglamorous reality of composing agents: cache lifespan quietly sets your real cost. Worth reading before you wire up any reviewer/programmer loop.
https://x.com/albertgao/status/2074798672546508944
The hidden tax of multi-model agent loops: prompt caches expire. In a code-review-fix loop, if the programmer sub-agent takes too long to implement a fix, the reviewer's cache has already expired by the time it's called back, so it starts from zero β and the loop can repeat N times if the reviewer keeps flagging false alarms. This is the unglamorous reality of composing agents: cache lifespan quietly sets your real cost. Worth reading before you wire up any reviewer/programmer loop.
#9
@Thor_DraperJr
https://x.com/Thor_DraperJr/status/2074982322542162027
Small but useful agent-loop lesson from a real run. When a tool scored one candidate at a time, the model turned judgment into a long, narrated loop. Switching to batch scoring changed the behavior entirely β fewer calls, less narration, cleaner decisions. His takeaway: the tool shape mattered as much as the prompt. A concrete example of how loop design, not model choice, drives behavior.
https://x.com/Thor_DraperJr/status/2074982322542162027
Small but useful agent-loop lesson from a real run. When a tool scored one candidate at a time, the model turned judgment into a long, narrated loop. Switching to batch scoring changed the behavior entirely β fewer calls, less narration, cleaner decisions. His takeaway: the tool shape mattered as much as the prompt. A concrete example of how loop design, not model choice, drives behavior.
#10
@TheYotg
https://x.com/TheYotg/status/2074801429680734282
The deepest systems take of the day. He walks through Experience Graphs and Trellis β the argument that long-horizon agents produce a structured "experience graph" (artifacts, tool outputs, rewards, causal lineage) that current frameworks throw away as disposable JSON. Treat it as first-class database state and crash recovery, cross-session reuse, and a training flywheel fall out for free. The proof point: on Meta's KernelEvolve, cross-session memory hit a target speedup ~10x faster at 52% lower token cost. Memory is becoming infrastructure, not a prompt trick.
https://x.com/TheYotg/status/2074801429680734282
The deepest systems take of the day. He walks through Experience Graphs and Trellis β the argument that long-horizon agents produce a structured "experience graph" (artifacts, tool outputs, rewards, causal lineage) that current frameworks throw away as disposable JSON. Treat it as first-class database state and crash recovery, cross-session reuse, and a training flywheel fall out for free. The proof point: on Meta's KernelEvolve, cross-session memory hit a target speedup ~10x faster at 52% lower token cost. Memory is becoming infrastructure, not a prompt trick.
#11
@Shilong_Liu_AI
https://x.com/Shilong_Liu_AI/status/2074942031676461216
The clearest taxonomy in the self-evolving conversation. He splits self-evolving systems into three components β the model, the harness, and the artifacts the agent produces β which cleanly separates work that optimizes artifacts, work that improves the harness, and work that updates the model itself. It's the framing everyone was implicitly using today made explicit. If you're confused by the flood of "self-improving agent" claims, this is the map to read them against.
https://x.com/Shilong_Liu_AI/status/2074942031676461216
The clearest taxonomy in the self-evolving conversation. He splits self-evolving systems into three components β the model, the harness, and the artifacts the agent produces β which cleanly separates work that optimizes artifacts, work that improves the harness, and work that updates the model itself. It's the framing everyone was implicitly using today made explicit. If you're confused by the flood of "self-improving agent" claims, this is the map to read them against.
#12
@jimclydego
https://x.com/jimclydego/status/2074856079616295078
The right warning about self-improvement loops. Reviewing a repo where the harness itself is the optimization target β the agent mines failed runs, proposes bounded edits, and tests whether they improve the system β he makes the key point: "let the agent improve itself" is the wrong mental model. The loop optimizes whatever signal you give it, so the evaluator, scoring logic, permissions, and runtime boundaries must stay outside the parts the agent can rewrite. Otherwise you're not building a self-improving agent, you're building a reward-hacker.
https://x.com/jimclydego/status/2074856079616295078
The right warning about self-improvement loops. Reviewing a repo where the harness itself is the optimization target β the agent mines failed runs, proposes bounded edits, and tests whether they improve the system β he makes the key point: "let the agent improve itself" is the wrong mental model. The loop optimizes whatever signal you give it, so the evaluator, scoring logic, permissions, and runtime boundaries must stay outside the parts the agent can rewrite. Otherwise you're not building a self-improving agent, you're building a reward-hacker.
#13
@Adham__Khaled__
https://x.com/Adham__Khaled__/status/2074883109724553545
A concrete data point that self-improvement can start outside the model. Referencing DGM, he notes the base model (Claude 3.5 Sonnet) stayed fixed while the agents edited their own surrounding code β and Polyglot moved from 14.2% to 30.7%. No weight update required. The reframing is the useful part: stop thinking bigger prompts, start thinking workflow-as-editable-code, context stored in files, evals outside the loop, logs that survive restarts. The scaffold is the thing you can search over.
https://x.com/Adham__Khaled__/status/2074883109724553545
A concrete data point that self-improvement can start outside the model. Referencing DGM, he notes the base model (Claude 3.5 Sonnet) stayed fixed while the agents edited their own surrounding code β and Polyglot moved from 14.2% to 30.7%. No weight update required. The reframing is the useful part: stop thinking bigger prompts, start thinking workflow-as-editable-code, context stored in files, evals outside the loop, logs that survive restarts. The scaffold is the thing you can search over.
#14
@HenryL_AI
https://x.com/HenryL_AI/status/2074896018563530968
The best measurement idea today. Responding to Lilian Weng's self-improving-AI survey, he argues the real metric isn't benchmarks, it's comfort: how many GPU-hours are humans willing to hand the system unattended? He points to history β in 2023 nobody let a model edit their codebase unattended, and Cursor's real invention wasn't a better model, it was the per-diff accept/reject that built trust. Now in 2026 almost everyone runs agent mode and accepts every change. Trust, not capability, is the gating variable.
https://x.com/HenryL_AI/status/2074896018563530968
The best measurement idea today. Responding to Lilian Weng's self-improving-AI survey, he argues the real metric isn't benchmarks, it's comfort: how many GPU-hours are humans willing to hand the system unattended? He points to history β in 2023 nobody let a model edit their codebase unattended, and Cursor's real invention wasn't a better model, it was the per-diff accept/reject that built trust. Now in 2026 almost everyone runs agent mode and accepts every change. Trust, not capability, is the gating variable.
#15
@LeeLeepenkman
https://x.com/LeeLeepenkman/status/2074698445126877516
Autoresearch pointed at markets. He's priming his LLM to work on an auto-research trading bot (the stock-prediction repo), a small but real example of the loop escaping the coding-benchmark bubble into finance. The pattern generalizes cleanly: a strategy you can backtest is a measurable target, which is exactly what an autoresearch loop needs. Expect more of these once people realize the harness doesn't care whether the metric is a kernel or a Sharpe ratio.
https://x.com/LeeLeepenkman/status/2074698445126877516
Autoresearch pointed at markets. He's priming his LLM to work on an auto-research trading bot (the stock-prediction repo), a small but real example of the loop escaping the coding-benchmark bubble into finance. The pattern generalizes cleanly: a strategy you can backtest is a measurable target, which is exactly what an autoresearch loop needs. Expect more of these once people realize the harness doesn't care whether the metric is a kernel or a Sharpe ratio.
#16
@thealokverse
https://x.com/thealokverse/status/2074841671796428982
A from-scratch agent as a learning exercise, shipped. Blazecode v1.0.0 is a lightweight terminal coding agent in Python built around a ReAct-style agent loop, inspired by Codex, OpenCode, and Pi. The value here isn't the tool competing with the big harnesses β it's that building your own loop is now a weekend project, and the more people who do it, the better the collective understanding of what actually makes a loop work. Transparent-by-design beats black box for learning.
https://x.com/thealokverse/status/2074841671796428982
A from-scratch agent as a learning exercise, shipped. Blazecode v1.0.0 is a lightweight terminal coding agent in Python built around a ReAct-style agent loop, inspired by Codex, OpenCode, and Pi. The value here isn't the tool competing with the big harnesses β it's that building your own loop is now a weekend project, and the more people who do it, the better the collective understanding of what actually makes a loop work. Transparent-by-design beats black box for learning.
#17
@TeksCreate
https://x.com/TeksCreate/status/2074972318250512628
The educational-harness trend, quantified. shareAI-lab/learn-claude-code replicates Claude Code's agent loop in ~500 lines of Python β tool calling, file editing, bash execution, self-correction β and hit 70K stars in under two weeks. The signal he reads is right: the market is shifting from "use our agent" to "understand how agents work so you can build your own." When the reference implementation of the loop is 500 readable lines, the moat was never the loop.
https://x.com/TeksCreate/status/2074972318250512628
The educational-harness trend, quantified. shareAI-lab/learn-claude-code replicates Claude Code's agent loop in ~500 lines of Python β tool calling, file editing, bash execution, self-correction β and hit 70K stars in under two weeks. The signal he reads is right: the market is shifting from "use our agent" to "understand how agents work so you can build your own." When the reference implementation of the loop is 500 readable lines, the moat was never the loop.
#18
@DanKornas
https://x.com/DanKornas/status/2074653186045137154
Agentic loops leaving the datacenter. ESP-Claw is Espressif's chat-coding agent framework for IoT devices running on ESP32 chips β you define device behavior through conversation, with an event-driven agent loop where device events trigger sensing, decision-making, and execution locally, plus on-device structured memory so private context never touches the cloud. This is the loop pattern applied to hardware, and the on-device memory angle is the interesting part. Open source, Apache 2.0.
https://x.com/DanKornas/status/2074653186045137154
Agentic loops leaving the datacenter. ESP-Claw is Espressif's chat-coding agent framework for IoT devices running on ESP32 chips β you define device behavior through conversation, with an event-driven agent loop where device events trigger sensing, decision-making, and execution locally, plus on-device structured memory so private context never touches the cloud. This is the loop pattern applied to hardware, and the on-device memory angle is the interesting part. Open source, Apache 2.0.
#19
@cdiamond
https://x.com/cdiamond/status/2074851278010630415
The cleanest statement of the economics shift. Reading GPT-5.6's pricing, he argues the differentiator isn't the model, it's the cache: 90% off cache reads, 30-minute minimum cache life, OpenAI pricing a long-running agent's memory like AWS priced reserved instances. His framing: the old game was which model wins the leaderboard, the new game is whose agent loop survives the invoice. Prompt caching is the new reserved instance, and the model wars just became cache-economics wars.
https://x.com/cdiamond/status/2074851278010630415
The cleanest statement of the economics shift. Reading GPT-5.6's pricing, he argues the differentiator isn't the model, it's the cache: 90% off cache reads, 30-minute minimum cache life, OpenAI pricing a long-running agent's memory like AWS priced reserved instances. His framing: the old game was which model wins the leaderboard, the new game is whose agent loop survives the invoice. Prompt caching is the new reserved instance, and the model wars just became cache-economics wars.
#20
@Vtrivedy10
https://x.com/Vtrivedy10/status/2074886193074815118
A practitioner's argument against one-size-fits-all harnesses. He makes the case for Model-Harness-Task fit: swapping models into the same harness leaves performance on the table, especially for open models. The fix is harness profiles β tailoring prompts, tool signatures, and built-in skills per model, where each profile is fit via an auto-research-style loop plus human review. Run that loop for every task you care about. This is autoresearch applied to the harness itself, not just the code it writes.
https://x.com/Vtrivedy10/status/2074886193074815118
A practitioner's argument against one-size-fits-all harnesses. He makes the case for Model-Harness-Task fit: swapping models into the same harness leaves performance on the table, especially for open models. The fix is harness profiles β tailoring prompts, tool signatures, and built-in skills per model, where each profile is fit via an auto-research-style loop plus human review. Run that loop for every task you care about. This is autoresearch applied to the harness itself, not just the code it writes.
#21
@nasqret
https://x.com/nasqret/status/2074847411193708784
Autoresearch reaching into mathematics. Back from three days in Prague talking with researchers about auto-research, SMT solvers, and the future of verified software, he came away understanding much more about the role AI can play in theorem proving and applying engineering methods to mathematics at scale. It's early and conversational, but it's a real signal that the autoresearch loop is being seriously considered for formal math, not just kernels and benchmarks. Different domain, same primitive.
https://x.com/nasqret/status/2074847411193708784
Autoresearch reaching into mathematics. Back from three days in Prague talking with researchers about auto-research, SMT solvers, and the future of verified software, he came away understanding much more about the role AI can play in theorem proving and applying engineering methods to mathematics at scale. It's early and conversational, but it's a real signal that the autoresearch loop is being seriously considered for formal math, not just kernels and benchmarks. Different domain, same primitive.
#22
@PostleTyler
https://x.com/PostleTyler/status/2074929027702210918
A useful reality check on the self-improving hype. He lays out the levels of agent optimization: first just rewriting its own prompt, then prompt plus skills, then prompt, skills, and tools it controls β the more variables it controls, the more it can improve, but also the more ways to optimize itself into a corner. His punchline: most agents claiming to be self-improving are barely operating at level one. A good filter to hold up against every "self-improving agent" post from today.
https://x.com/PostleTyler/status/2074929027702210918
A useful reality check on the self-improving hype. He lays out the levels of agent optimization: first just rewriting its own prompt, then prompt plus skills, then prompt, skills, and tools it controls β the more variables it controls, the more it can improve, but also the more ways to optimize itself into a corner. His punchline: most agents claiming to be self-improving are barely operating at level one. A good filter to hold up against every "self-improving agent" post from today.
π‘ Eco Products Radar
Eco Products Radar
Codex β the executor behind the day's biggest autoresearch win (212x kernel) and the inspiration behind new from-scratch agents.
autoresearch-at-home β the Karpathy-seeded leaderboard people are now racing on with home GPUs.
LangChain / DeepAgents β harness profiles and continual-learning tooling for fitting open models per task.
DGM (Darwin Godel Machine) β the reference point for self-improvement by editing the scaffold, not the weights.
Trellis / Experience Graphs β the memory-as-database approach that treats agent state as first-class, queryable data.
learn-claude-code / Blazecode β the educational, ~500-line from-scratch implementations of the agent loop.
Codex β the executor behind the day's biggest autoresearch win (212x kernel) and the inspiration behind new from-scratch agents.
autoresearch-at-home β the Karpathy-seeded leaderboard people are now racing on with home GPUs.
LangChain / DeepAgents β harness profiles and continual-learning tooling for fitting open models per task.
DGM (Darwin Godel Machine) β the reference point for self-improvement by editing the scaffold, not the weights.
Trellis / Experience Graphs β the memory-as-database approach that treats agent state as first-class, queryable data.
learn-claude-code / Blazecode β the educational, ~500-line from-scratch implementations of the agent loop.
Comments