Loop Daily: July 18, 2026
The loop stopped being the interesting part today. Everyone can run an agent overnight now — the fights have all moved to what grades the work while you sleep. Recursive self-improvement went from slide-deck to hard numbers, but the same crowd shouting about it also spent the day admitting the model can't mark its own homework, so the verifier is the whole game. Around that, two quieter threads: people writing down what a loop actually is (four shapes, five ways it dies) instead of vibing it, and self-improving harnesses showing up in places that have nothing to do with coding — a Unity editor, a 1980s RPG, a factory floor.
#1
@zhengyaojiang
https://x.com/zhengyaojiang/status/2077868497208791369
After publishing this week's recursive self-improvement results, he laid out what the AI/ML researcher's job collapses into once autoresearch does the grunt work: coming up with creative primitives, defining a good abstraction for the agent to search within, and defining a good eval for what "good" even means. His point is the role doesn't disappear, it distills to the three things a loop can't do for you. The full argument is in his aiDotEngineer talk. Notice all three surviving skills are about framing the search, not running it.
https://x.com/zhengyaojiang/status/2077868497208791369
After publishing this week's recursive self-improvement results, he laid out what the AI/ML researcher's job collapses into once autoresearch does the grunt work: coming up with creative primitives, defining a good abstraction for the agent to search within, and defining a good eval for what "good" even means. His point is the role doesn't disappear, it distills to the three things a loop can't do for you. The full argument is in his aiDotEngineer talk. Notice all three surviving skills are about framing the search, not running it.
#2
@erogol
https://x.com/erogol/status/2077728683767308643
This is the most honest autoresearch writeup of the day. He ran ~120 experiments and 22 full training runs on BlaGPT for architecture search, about $1,300 of compute, and moved val loss from 3.2354 to 3.1965. The real lessons weren't the wins: twice the "best result of the run" was just a lucky seed, caught only because he'd hardcoded a mandatory rerun rule, and every mechanism the agent invented for itself died — all six keepers came from published papers. He shipped the harness rules, the full ledger, and a graveyard of ~15 failures in the repo. That graveyard is worth more than the loss number.
https://x.com/erogol/status/2077728683767308643
This is the most honest autoresearch writeup of the day. He ran ~120 experiments and 22 full training runs on BlaGPT for architecture search, about $1,300 of compute, and moved val loss from 3.2354 to 3.1965. The real lessons weren't the wins: twice the "best result of the run" was just a lucky seed, caught only because he'd hardcoded a mandatory rerun rule, and every mechanism the agent invented for itself died — all six keepers came from published papers. He shipped the harness rules, the full ledger, and a graveyard of ~15 failures in the repo. That graveyard is worth more than the loss number.
#3
@nishu_lahoti
https://x.com/nishu_lahoti/status/2077802644228493572
He built a self-improving layer that sits on top of his coding agents to manage context, and says the unlock wasn't a newer model, it was a factory that guides the agents and gets sharper every session. He pointed Claude Code at two years of his own repos and had it codify principles, recipes, and failure modes per task — so now a database-migration skill auto-triggers mid-session, assesses impact, and walks him through a safe sequence without being reminded. He scopes each session tightly through Linear's MCP and feeds machine-readable tools (Granola, GitHub, Supabase) straight in via CLI. He open-sourced the skills library as a single npx command that symlinks into any CLAUDE.md.
https://x.com/nishu_lahoti/status/2077802644228493572
He built a self-improving layer that sits on top of his coding agents to manage context, and says the unlock wasn't a newer model, it was a factory that guides the agents and gets sharper every session. He pointed Claude Code at two years of his own repos and had it codify principles, recipes, and failure modes per task — so now a database-migration skill auto-triggers mid-session, assesses impact, and walks him through a safe sequence without being reminded. He scopes each session tightly through Linear's MCP and feeds machine-readable tools (Granola, GitHub, Supabase) straight in via CLI. He open-sourced the skills library as a single npx command that symlinks into any CLAUDE.md.
#4
@martin_casado
https://x.com/martin_casado/status/2077791409428656334
He's been running a self-improving harness that learns to play Phantasy Star 1 by writing its own tools, and the emergent behavior is the story. Starting from just screenshots, the agent decided images were too inaccurate and built a probe to read the emulator's RAM directly for x, y and map ID. Then it realized sending images was too expensive and wrote a gif-to-ascii converter to cut its own costs. Combined with its latent knowledge of the game's walkthroughs, it now plays very well — a clean example of an agent re-engineering its own perception to fit its budget.
https://x.com/martin_casado/status/2077791409428656334
He's been running a self-improving harness that learns to play Phantasy Star 1 by writing its own tools, and the emergent behavior is the story. Starting from just screenshots, the agent decided images were too inaccurate and built a probe to read the emulator's RAM directly for x, y and map ID. Then it realized sending images was too expensive and wrote a gif-to-ascii converter to cut its own costs. Combined with its latent knowledge of the game's walkthroughs, it now plays very well — a clean example of an agent re-engineering its own perception to fit its budget.
#5
@Roger_M_Taylor
https://x.com/Roger_M_Taylor/status/2077747074309771310
He tried to vibe-code a TypeScript harness, watched it fall apart in the details, deleted everything, and rebuilt it as Squid — a software factory that behaves like an engineering org instead of one giant prompt. It runs six specialized agents (Product Architect, Software Engineer, Tester, PR Reviewer, On-call Engineer, and a Self-improvement Agent), captures decisions as ADRs, and keeps a shared glossary so every task starts with better context. Each feature moves through planning, TDD, adversarial testing, PR review, CI, and human approval, with retry limits on every loop. He open-sourced the whole thing.
https://x.com/Roger_M_Taylor/status/2077747074309771310
He tried to vibe-code a TypeScript harness, watched it fall apart in the details, deleted everything, and rebuilt it as Squid — a software factory that behaves like an engineering org instead of one giant prompt. It runs six specialized agents (Product Architect, Software Engineer, Tester, PR Reviewer, On-call Engineer, and a Self-improvement Agent), captures decisions as ADRs, and keeps a shared glossary so every task starts with better context. Each feature moves through planning, TDD, adversarial testing, PR review, CI, and human approval, with retry limits on every loop. He open-sourced the whole thing.
#6
@hanakoxbt
https://x.com/hanakoxbt/status/2077885956959457494
A field guide to the five ways an overnight agent loop dies, and it's all operational, not theoretical. Context rot — 200 turns in it contradicts a turn-3 decision, so write state to disk and reload only what the turn needs. The doom spiral — it retries the same broken fix all night, so cap retries at three then page a human. Silent drift — it slowly stops matching spec, so grade every output against a rubric before it ships. The runaway and the amnesiac crash get the same treatment: a hard-limit contract it reads before every wake, and a checkpoint after every step so a crash resumes instead of restarting blind.
https://x.com/hanakoxbt/status/2077885956959457494
A field guide to the five ways an overnight agent loop dies, and it's all operational, not theoretical. Context rot — 200 turns in it contradicts a turn-3 decision, so write state to disk and reload only what the turn needs. The doom spiral — it retries the same broken fix all night, so cap retries at three then page a human. Silent drift — it slowly stops matching spec, so grade every output against a rubric before it ships. The runaway and the amnesiac crash get the same treatment: a hard-limit contract it reads before every wake, and a checkpoint after every step so a crash resumes instead of restarting blind.
#7
@Abobsterina
https://x.com/Abobsterina/status/2077834278583361635
The cleanest taxonomy of agent loops going around: there are four, and every one answers two questions — what starts a run and what ends it. Turn-based keeps both with you (right while requirements are still forming). Goal-based hands off the stop condition to an evaluator. Time-based hands off the trigger to a clock. Proactive hands off the prompt itself, watching a channel and spawning its own triage-fix-review agents. The insight worth stealing: the question is never which loop is most advanced, it's what shape your task actually has — and most people babysit turn-based work that should've been handed off two structures ago.
https://x.com/Abobsterina/status/2077834278583361635
The cleanest taxonomy of agent loops going around: there are four, and every one answers two questions — what starts a run and what ends it. Turn-based keeps both with you (right while requirements are still forming). Goal-based hands off the stop condition to an evaluator. Time-based hands off the trigger to a clock. Proactive hands off the prompt itself, watching a channel and spawning its own triage-fix-review agents. The insight worth stealing: the question is never which loop is most advanced, it's what shape your task actually has — and most people babysit turn-based work that should've been handed off two structures ago.
#8
@0xGhostnt
https://x.com/0xGhostnt/status/2077837316526063857
The necessary footnote to that taxonomy: each step up doesn't just transfer a job, it transfers a failure mode to a place you're no longer watching. Turn-based fails loudly because you're standing there; proactive fails silently, potentially across dozens of runs, before anyone notices. So the less you babysit, the more verification infrastructure you need to replace what your presence was catching. His matching heuristic is the sharpest line: push a task to proactive only if it has a stop condition you trust and a failure mode you can detect without being present.
https://x.com/0xGhostnt/status/2077837316526063857
The necessary footnote to that taxonomy: each step up doesn't just transfer a job, it transfers a failure mode to a place you're no longer watching. Turn-based fails loudly because you're standing there; proactive fails silently, potentially across dozens of runs, before anyone notices. So the less you babysit, the more verification infrastructure you need to replace what your presence was catching. His matching heuristic is the sharpest line: push a task to proactive only if it has a stop condition you trust and a failure mode you can detect without being present.
#9
@0xRokko
https://x.com/0xRokko/status/2077899914927841689
He turns Shunyu Yao — the creator of ReAct — into the day's blunt reminder: the guy who invented the agent loop says the model still can't grade its own work, yet everyone lets it mark its own homework and ships the A it gives itself. The receipts: ReAct with a handful of examples hit 40% and beat an RL agent trained on 100,000 samples, and on real GitHub issues a plain model solved 2% while bolting a reason-act-observe loop on top pushed past 10%. Same model, 5x the result. The difference was never the prompt, it was the verifier — your taste, written down strict enough that a machine enforces it.
https://x.com/0xRokko/status/2077899914927841689
He turns Shunyu Yao — the creator of ReAct — into the day's blunt reminder: the guy who invented the agent loop says the model still can't grade its own work, yet everyone lets it mark its own homework and ships the A it gives itself. The receipts: ReAct with a handful of examples hit 40% and beat an RL agent trained on 100,000 samples, and on real GitHub issues a plain model solved 2% while bolting a reason-act-observe loop on top pushed past 10%. Same model, 5x the result. The difference was never the prompt, it was the verifier — your taste, written down strict enough that a machine enforces it.
#10
@beamnxw
https://x.com/beamnxw/status/2077701587200246209
Why he stopped using single-agent verification loops, in mechanism terms. Once a model outputs a wrong answer with high confidence it hits Degeneration-of-Thought — tell it to "think again" ten times and it finds ten new ways to justify the original mistake. His fix is Multi-Agent Debate: independent agents generate without seeing each other's bias, cross-examine each other's logic tit-for-tat, and get filtered by an independent judge. The detail most frameworks miss, and he flags it: using one LLM family as the judge introduces favoritism toward its own sibling outputs.
https://x.com/beamnxw/status/2077701587200246209
Why he stopped using single-agent verification loops, in mechanism terms. Once a model outputs a wrong answer with high confidence it hits Degeneration-of-Thought — tell it to "think again" ten times and it finds ten new ways to justify the original mistake. His fix is Multi-Agent Debate: independent agents generate without seeing each other's bias, cross-examine each other's logic tit-for-tat, and get filtered by an independent judge. The detail most frameworks miss, and he flags it: using one LLM family as the judge introduces favoritism toward its own sibling outputs.
#11
@diamai_
https://x.com/diamai_/status/2077793706321859019
A talk breakdown that puts a price tag on the routing problem. Profiling a single agent benchmark cost Melissa Pan's team about $11,000, and the cheapest vs most expensive valid configuration differed by roughly 1,000x — so exhaustive search per workload is dead on arrival. Two near-identical questions can need entirely different pipelines: same model answers one from weights and hallucinates the other until web search is on. Her system, BRANE, gives each candidate config a classical predictor and picks the cheapest one likely to hit the accuracy target — the only method that met a 100% accuracy bar on three benchmarks while cutting cost up to 89%.
https://x.com/diamai_/status/2077793706321859019
A talk breakdown that puts a price tag on the routing problem. Profiling a single agent benchmark cost Melissa Pan's team about $11,000, and the cheapest vs most expensive valid configuration differed by roughly 1,000x — so exhaustive search per workload is dead on arrival. Two near-identical questions can need entirely different pipelines: same model answers one from weights and hallucinates the other until web search is on. Her system, BRANE, gives each candidate config a classical predictor and picks the cheapest one likely to hit the accuracy target — the only method that met a 100% accuracy bar on three benchmarks while cutting cost up to 89%.
#12
@MachJustine
https://x.com/MachJustine/status/2077822677658816930
An interview with Stefania Druga, now at Sakana's recursive self-improvement lab, that's refreshingly about the failure modes. They get into catastrophic forgetting in day-long agent research runs and how memory-first harnesses help, the case for sovereign AI and open weights so you build on models you control instead of locking into one provider, and why computer use still frustrates people even as models get smarter. Her list of domains ripe for self-improving research agents — math, genomics, rare conditions — is a useful map of where the loop actually pays off first.
https://x.com/MachJustine/status/2077822677658816930
An interview with Stefania Druga, now at Sakana's recursive self-improvement lab, that's refreshingly about the failure modes. They get into catastrophic forgetting in day-long agent research runs and how memory-first harnesses help, the case for sovereign AI and open weights so you build on models you control instead of locking into one provider, and why computer use still frustrates people even as models get smarter. Her list of domains ripe for self-improving research agents — math, genomics, rare conditions — is a useful map of where the loop actually pays off first.
#13
@soubhikdeb
https://x.com/soubhikdeb/status/2077841331725201818
The most thought-through argument for open, competitive autoresearch as a new form of research training. His team at Eigenlabs runs open leaderboard competitions (ecdsa.fail, openfrontiercs) where almost none of the participants are subject-matter experts, yet they investigate each other's submissions and build on them in hours instead of waiting months for feedback. The load-bearing component, he stresses, is the verifier that checks correctness and performance — and when progress plateaus, an expert steering the community of autoresearchers is the unlock. His pitch to PIs: this is what recruiting and training the next generation of researchers looks like post-AGI.
https://x.com/soubhikdeb/status/2077841331725201818
The most thought-through argument for open, competitive autoresearch as a new form of research training. His team at Eigenlabs runs open leaderboard competitions (ecdsa.fail, openfrontiercs) where almost none of the participants are subject-matter experts, yet they investigate each other's submissions and build on them in hours instead of waiting months for feedback. The load-bearing component, he stresses, is the verifier that checks correctness and performance — and when progress plateaus, an expert steering the community of autoresearchers is the unlock. His pitch to PIs: this is what recruiting and training the next generation of researchers looks like post-AGI.
#14
@stretchcloud
https://x.com/stretchcloud/status/2077694983185080721
A concrete case of the loop building the product. Aster shipped an inference API — gpt-oss-120b at 644 tokens/sec, GLM 5.2 at 281 — but the mechanism is the point: they built the product out of what their own AI research agents discovered, treating inference optimization as a task the agents benchmark themselves against, and whatever they find ships directly. No dedicated kernel-hunting team. His read is that if agent loops shorten the gap between benchmark discovery and production deployment, the barrier to entry in inference infrastructure — historically years of systems expertise — drops hard.
https://x.com/stretchcloud/status/2077694983185080721
A concrete case of the loop building the product. Aster shipped an inference API — gpt-oss-120b at 644 tokens/sec, GLM 5.2 at 281 — but the mechanism is the point: they built the product out of what their own AI research agents discovered, treating inference optimization as a task the agents benchmark themselves against, and whatever they find ships directly. No dedicated kernel-hunting team. His read is that if agent loops shorten the gap between benchmark discovery and production deployment, the barrier to entry in inference infrastructure — historically years of systems expertise — drops hard.
#15
@lamiancegames
https://x.com/lamiancegames/status/2077829095405334983
A very tangible harness-speed fix from game dev. Right now an agent mutating a Unity prefab goes through edit mode, paying a domain reload plus a full assembly recompile on every change, which serializes the whole agent loop behind the compiler. His new feature is a runtime interpreter for the agent's C# that executes against live app state instead of emitting code into the assembly — no rebuild, no play-mode restart. Agents get to patch prefabs and read/write component fields while the game runs, collapsing edit-compile-reload-replay into a single live call.
https://x.com/lamiancegames/status/2077829095405334983
A very tangible harness-speed fix from game dev. Right now an agent mutating a Unity prefab goes through edit mode, paying a domain reload plus a full assembly recompile on every change, which serializes the whole agent loop behind the compiler. His new feature is a runtime interpreter for the agent's C# that executes against live app state instead of emitting code into the assembly — no rebuild, no play-mode restart. Agents get to patch prefabs and read/write component fields while the game runs, collapsing edit-compile-reload-replay into a single live call.
#16
@MichaelGannotti
https://x.com/MichaelGannotti/status/2077769339978011120
A real autonomous-agent-in-the-wild anecdote: his Nous Hermes agent "Jasmine," running on Windows 11 in a Microsoft 365 tenant, took an interest in the open issues on the Hermes repo itself. It queried Grok for a prioritized list of the top issues, got back a ranked breakdown of session-state bugs and delegation-safety problems, and is now looking to address some of them. An agent triaging the backlog of the very framework it runs on is exactly the dogfooding loop everyone talks about, actually happening.
https://x.com/MichaelGannotti/status/2077769339978011120
A real autonomous-agent-in-the-wild anecdote: his Nous Hermes agent "Jasmine," running on Windows 11 in a Microsoft 365 tenant, took an interest in the open issues on the Hermes repo itself. It queried Grok for a prioritized list of the top issues, got back a ranked breakdown of session-state bugs and delegation-safety problems, and is now looking to address some of them. An agent triaging the backlog of the very framework it runs on is exactly the dogfooding loop everyone talks about, actually happening.
#17
@keremakillioglu
https://x.com/keremakillioglu/status/2077793605260104076
He flags Exo as a rare example of the self-improving idea applied to the harness rather than the model: the agent rewrites its own policy, tools, and wiring, with rollback keeping the evolution safe. Most agent systems today are static — the scaffold is fixed and only the prompts move — so a harness that edits itself and can revert a bad change is a meaningfully different shape. The rollback is the part that makes it shippable rather than a science-fair demo.
https://x.com/keremakillioglu/status/2077793605260104076
He flags Exo as a rare example of the self-improving idea applied to the harness rather than the model: the agent rewrites its own policy, tools, and wiring, with rollback keeping the evolution safe. Most agent systems today are static — the scaffold is fixed and only the prompts move — so a harness that edits itself and can revert a bad change is a meaningfully different shape. The rollback is the part that makes it shippable rather than a science-fair demo.
#18
@casper_calls
https://x.com/casper_calls/status/2077875403566219338
A concrete self-hosted autoresearch rig: a student spent roughly $4,000 on two Mac Studios and a Mac mini to run a personal Claude-plus-Obsidian workstation 24/7. The workflow is three commands — /wiki to initialize a project, /save to persist conversation and knowledge, and /autoresearch for deep research with automatic citations — and each machine has a dedicated role across UI/UX, dev, and admin. The system breaks work into dozens of microtasks, runs them in parallel, and refreshes the knowledge base every one to three hours. It's a small, real picture of what a private always-on research loop costs to stand up.
https://x.com/casper_calls/status/2077875403566219338
A concrete self-hosted autoresearch rig: a student spent roughly $4,000 on two Mac Studios and a Mac mini to run a personal Claude-plus-Obsidian workstation 24/7. The workflow is three commands — /wiki to initialize a project, /save to persist conversation and knowledge, and /autoresearch for deep research with automatic citations — and each machine has a dedicated role across UI/UX, dev, and admin. The system breaks work into dozens of microtasks, runs them in parallel, and refreshes the knowledge base every one to three hours. It's a small, real picture of what a private always-on research loop costs to stand up.
#19
@apaarmeet
https://x.com/apaarmeet/status/2077847422399816062
Build-in-public from first principles: he wrote his own AI coding harness and used it to ship a small game. The current toolset is deliberately minimal — Bash, file read/write, web search, streaming, tool calling, and the agent loop itself — with memory and RAG named as the next additions. It's a useful counter to the "just use a framework" reflex: building the loop by hand is how you actually learn what the abstractions are hiding.
https://x.com/apaarmeet/status/2077847422399816062
Build-in-public from first principles: he wrote his own AI coding harness and used it to ship a small game. The current toolset is deliberately minimal — Bash, file read/write, web search, streaming, tool calling, and the agent loop itself — with memory and RAG named as the next additions. It's a useful counter to the "just use a framework" reflex: building the loop by hand is how you actually learn what the abstractions are hiding.
#20
@real_deep_ml
https://x.com/real_deep_ml/status/2077739453263626269
An interesting inversion of the autoresearch idea: Deep-ML launched a feature that lets a person design and test different experiments for training an LLM, framed explicitly as "AutoResearch but built for people instead of AI agents" — HumanResearch. It's a hands-on way to learn how LLM research actually works by running real experiments rather than reading about them. As agents absorb the grunt work, tools that teach humans the experiment-design muscle are the complement, not the casualty.
https://x.com/real_deep_ml/status/2077739453263626269
An interesting inversion of the autoresearch idea: Deep-ML launched a feature that lets a person design and test different experiments for training an LLM, framed explicitly as "AutoResearch but built for people instead of AI agents" — HumanResearch. It's a hands-on way to learn how LLM research actually works by running real experiments rather than reading about them. As agents absorb the grunt work, tools that teach humans the experiment-design muscle are the complement, not the casualty.
#21
@macrocrux
https://x.com/macrocrux/status/2077839131179127023
A snapshot of autoresearch at real scale: a few million tokens, 200 GPUs, 24 hours, and an autoresearch loop, with the team now tuning the system for the next run and reporting promising gains from the improvements. It's short on specifics but useful as a data point on what an industrial-grade overnight loop looks like in resources — the "one script, one GPU, overnight" story scaled up two orders of magnitude.
https://x.com/macrocrux/status/2077839131179127023
A snapshot of autoresearch at real scale: a few million tokens, 200 GPUs, 24 hours, and an autoresearch loop, with the team now tuning the system for the next run and reporting promising gains from the improvements. It's short on specifics but useful as a data point on what an industrial-grade overnight loop looks like in resources — the "one script, one GPU, overnight" story scaled up two orders of magnitude.
📡 Eco Products Radar
Eco Products Radar
Fable 5 — the model most-cited as the engine behind the day's loop-engineering courses and agentic builds.
Claude Code / CLAUDE.md — the recurring substrate people point their self-improving skills libraries at.
Hermes (Nous Research) — the self-improving agent framework behind the "Jasmine triages her own repo" and persistent-memory examples.
Grok Build — xAI's now-open-sourced Rust coding agent, repeatedly cited for making the agent loop auditable.
Kimi K3 — the model whose "RSI vibes" (autoresearch speedup, kernel optimization) came up across multiple loop threads.
MCP — the connective layer (Linear, GitHub, Supabase) people use to scope and feed their agent loops.
Fable 5 — the model most-cited as the engine behind the day's loop-engineering courses and agentic builds.
Claude Code / CLAUDE.md — the recurring substrate people point their self-improving skills libraries at.
Hermes (Nous Research) — the self-improving agent framework behind the "Jasmine triages her own repo" and persistent-memory examples.
Grok Build — xAI's now-open-sourced Rust coding agent, repeatedly cited for making the agent loop auditable.
Kimi K3 — the model whose "RSI vibes" (autoresearch speedup, kernel optimization) came up across multiple loop threads.
MCP — the connective layer (Linear, GitHub, Supabase) people use to scope and feed their agent loops.
Comments