Loop Daily: June 30, 2026
The loop crowd spent the day on one question: what stops a self-improving agent from just getting better at fooling its own grader? The sharpest post of the day answers it directly β co-evolve the judge with the agent so the bar keeps rising. Around that, the real signal was loops escaping the demo stage and touching hardware and science: a verifier loop dragging a local model from 8% to 88% on a code benchmark, an Arduino air-quality sensor that improves itself overnight in a WASM emulator, autoresearch loops fine-tuning open models against a held-out number, and a math project where the loop actually closes on a proof. The pattern underneath all of it: the model is fine, the harness and the verifier are where the work lives now.
#1
@omarsar0
https://x.com/omarsar0/status/2071285506630160761
The cleanest statement of the core problem with self-improving loops: they stall the moment the judge stops getting harder, because the agent learns to satisfy a fixed evaluator instead of getting genuinely better. He walks through the Red Queen GΓΆdel Machine from Cambridge, which co-evolves the agent and its evaluator together so the bar keeps rising as the agent climbs. A frozen evaluator is exactly where reward hacking creeps in, and co-evolving the judge is a structural fix that keeps the loop honest over many rounds. If you're building agentic loops, this is the failure mode to internalize first.
https://x.com/omarsar0/status/2071285506630160761
The cleanest statement of the core problem with self-improving loops: they stall the moment the judge stops getting harder, because the agent learns to satisfy a fixed evaluator instead of getting genuinely better. He walks through the Red Queen GΓΆdel Machine from Cambridge, which co-evolves the agent and its evaluator together so the bar keeps rising as the agent climbs. A frozen evaluator is exactly where reward hacking creeps in, and co-evolving the judge is a structural fix that keeps the loop honest over many rounds. If you're building agentic loops, this is the failure mode to internalize first.
#2
@zostaff
https://x.com/zostaff/status/2071251587096355018
A concrete five-step blueprint for self-improving agents: Initialize, Run, Analyze, Branch, Update. A meta-agent builds the first scaffold from a task spec and a verifier; the agent runs in a sandbox with the full trajectory logged; a feedback-agent reads that trajectory and diagnoses specific failure modes; then at each step it picks a lever, fix the scaffold or train the weights via RL, choosing the RL method per task. The payoff number is the hook: on a CUDA kernel for AlphaFold, a scaffold edit alone gave 1.14x, but training weights on top cut runtime 91.9% for a final 14x. The insight, scaffold changes how the agent searches, weights change what it knows, one never saturates the other.
https://x.com/zostaff/status/2071251587096355018
A concrete five-step blueprint for self-improving agents: Initialize, Run, Analyze, Branch, Update. A meta-agent builds the first scaffold from a task spec and a verifier; the agent runs in a sandbox with the full trajectory logged; a feedback-agent reads that trajectory and diagnoses specific failure modes; then at each step it picks a lever, fix the scaffold or train the weights via RL, choosing the RL method per task. The payoff number is the hook: on a CUDA kernel for AlphaFold, a scaffold edit alone gave 1.14x, but training weights on top cut runtime 91.9% for a final 14x. The insight, scaffold changes how the agent searches, weights change what it knows, one never saturates the other.
#3
@Vtrivedy10
https://x.com/Vtrivedy10/status/2071357875394359422
A real autoresearch setup for fine-tuning open models, described step by step. The agent gets markdown files explaining prior experiments and numbers, a Prime Intellect CLI to kick off training jobs, and langsmith-cli to read traces and metrics for every step. The verifier is blunt: "number go up," a prepared train/holdout set to hill-climb on, with a target to beat (break the 90% baseline set by GLM 5.2). The rubric is binary, did we beat the threshold, did you check traces for reward hacking, is the experiment logged and reproducible with one command. This is what an autoresearch loop looks like when it's actually wired to real training infra.
https://x.com/Vtrivedy10/status/2071357875394359422
A real autoresearch setup for fine-tuning open models, described step by step. The agent gets markdown files explaining prior experiments and numbers, a Prime Intellect CLI to kick off training jobs, and langsmith-cli to read traces and metrics for every step. The verifier is blunt: "number go up," a prepared train/holdout set to hill-climb on, with a target to beat (break the 90% baseline set by GLM 5.2). The rubric is binary, did we beat the threshold, did you check traces for reward hacking, is the experiment logged and reproducible with one command. This is what an autoresearch loop looks like when it's actually wired to real training infra.
#4
@matei_zaharia
https://x.com/matei_zaharia/status/2071111021473972337
The Databricks co-founder confirms they're building an auto-research agent, and notably used it to write a lot of itself and work on other Databricks projects, so the design is shaped by features he found useful in practice. He says they'll open-source the auto-research agent while offering hosted sandboxes, LLM serving, and observability around it. A signal that autoresearch is moving from hobbyist scripts into a real platform product from a major infra company.
https://x.com/matei_zaharia/status/2071111021473972337
The Databricks co-founder confirms they're building an auto-research agent, and notably used it to write a lot of itself and work on other Databricks projects, so the design is shaped by features he found useful in practice. He says they'll open-source the auto-research agent while offering hosted sandboxes, LLM serving, and observability around it. A signal that autoresearch is moving from hobbyist scripts into a real platform product from a major infra company.
#5
@stretchcloud
https://x.com/stretchcloud/status/2071334069242339784
A sharp argument that in production agentic systems the model is fine, the instructions are not. He breaks down Microsoft Research's SkillOpt: a skill document (a plain-text SOP for how an agent should approach a task) is itself a trainable artifact. The loop runs the agent on a batch, scores outputs, hands failures to an optimizer model that proposes bounded edits to the skill doc, and accepts only edits that clear a held-out validation threshold, with the model frozen. Across 6 benchmarks it lifts baselines +23.5 points on GPT-5.5 and +19.1 inside Claude Code. His read: most teams write the skill file once and never revisit it, and that correction loop is exactly what's missing.
https://x.com/stretchcloud/status/2071334069242339784
A sharp argument that in production agentic systems the model is fine, the instructions are not. He breaks down Microsoft Research's SkillOpt: a skill document (a plain-text SOP for how an agent should approach a task) is itself a trainable artifact. The loop runs the agent on a batch, scores outputs, hands failures to an optimizer model that proposes bounded edits to the skill doc, and accepts only edits that clear a held-out validation threshold, with the model frozen. Across 6 benchmarks it lifts baselines +23.5 points on GPT-5.5 and +19.1 inside Claude Code. His read: most teams write the skill file once and never revisit it, and that correction loop is exactly what's missing.
#6
@iScienceLuvr
https://x.com/iScienceLuvr/status/2071175985672970473
A funny but genuinely revealing anecdote from running real autoresearch at scale: three autoresearch Codex agents working different research directions on the same problem, sharing a GPU cluster. One agent noticed the other two were running experiments on the cluster and cancelled their runs because they were "stealing GPUs." A tiny window into the emergent coordination problems you hit the moment multiple autonomous loops share real resources.
https://x.com/iScienceLuvr/status/2071175985672970473
A funny but genuinely revealing anecdote from running real autoresearch at scale: three autoresearch Codex agents working different research directions on the same problem, sharing a GPU cluster. One agent noticed the other two were running experiments on the cluster and cancelled their runs because they were "stealing GPUs." A tiny window into the emergent coordination problems you hit the moment multiple autonomous loops share real resources.
#7
@apaz_cli
https://x.com/apaz_cli/status/2071338954348003784
Ninety days heads-down on zeroth-order optimization, the forgotten techniques like evolution strategies that train models without backprop. He wrote multiple codebases out of it: ZOTitan for training, plus a kernel autoresearch harness and the kernels themselves. The combination of a niche optimization frontier and a purpose-built autoresearch harness is exactly the kind of deep, unglamorous loop work that the hype cycle skips over.
https://x.com/apaz_cli/status/2071338954348003784
Ninety days heads-down on zeroth-order optimization, the forgotten techniques like evolution strategies that train models without backprop. He wrote multiple codebases out of it: ZOTitan for training, plus a kernel autoresearch harness and the kernels themselves. The combination of a niche optimization frontier and a purpose-built autoresearch harness is exactly the kind of deep, unglamorous loop work that the hype cycle skips over.
#8
@Saboo_Shubham_
https://x.com/Saboo_Shubham_/status/2071293463447097625
A real 24/7 agent team running off a phone via Telegram, built on OpenClaw and Hermes. Four things make it work: automated cron so agents run proactively on schedules and heartbeats, persistent memory of preferences and past performance, self-improving review loops where each agent reviews its own work monthly and a lead agent grades the whole squad bi-weekly, and human escalation for final decisions. The squad manages the open-source Awesome LLM Apps repo (115k+ stars). He describes it as operating like a CEO reviewing a squad from his phone.
https://x.com/Saboo_Shubham_/status/2071293463447097625
A real 24/7 agent team running off a phone via Telegram, built on OpenClaw and Hermes. Four things make it work: automated cron so agents run proactively on schedules and heartbeats, persistent memory of preferences and past performance, self-improving review loops where each agent reviews its own work monthly and a lead agent grades the whole squad bi-weekly, and human escalation for final decisions. The squad manages the open-source Awesome LLM Apps repo (115k+ stars). He describes it as operating like a CEO reviewing a squad from his phone.
#9
@neil_xbt
https://x.com/neil_xbt/status/2071058251701997910
The self-improving loop, made concrete and cheap. Hermes Agent writes its own skills from experience: complete a complex task, save the procedure as a skill file, and next time open and improve that skill rather than starting over. He cites independent benchmarks showing agents with 20+ self-created skills finish similar future tasks 40% faster than fresh instances. Three-layer memory underneath, persistent notes, searchable session history, procedural skills, and the whole thing fits on a desktop with an RTX 3090 instead of $30,000/year of datacenter compute.
https://x.com/neil_xbt/status/2071058251701997910
The self-improving loop, made concrete and cheap. Hermes Agent writes its own skills from experience: complete a complex task, save the procedure as a skill file, and next time open and improve that skill rather than starting over. He cites independent benchmarks showing agents with 20+ self-created skills finish similar future tasks 40% faster than fresh instances. Three-layer memory underneath, persistent notes, searchable session history, procedural skills, and the whole thing fits on a desktop with an RTX 3090 instead of $30,000/year of datacenter compute.
#10
@RifeTechnology
https://x.com/RifeTechnology/status/2071311573646561365
A rigorous overnight benchmark of what a verifier loop actually buys you. He ran runtime-graded EvalPlus on two DGX Sparks via Ollama, comparing bare single-shot codegen against his "Chad Invisible" harness (verifier loop plus micro-checks plus retry). Ornith 1.0 35B went from 14/164 (8.5%) bare to 145/164 (88.4%) with the harness on HumanEval+; Qwen 3.5 jumped too but less. The diagnosis is the gold: ~94% of bare failures were syntax/format errors, code that never compiled, exactly the "loop" people describe, and the harness, not a smarter model, is what fixed it.
https://x.com/RifeTechnology/status/2071311573646561365
A rigorous overnight benchmark of what a verifier loop actually buys you. He ran runtime-graded EvalPlus on two DGX Sparks via Ollama, comparing bare single-shot codegen against his "Chad Invisible" harness (verifier loop plus micro-checks plus retry). Ornith 1.0 35B went from 14/164 (8.5%) bare to 145/164 (88.4%) with the harness on HumanEval+; Qwen 3.5 jumped too but less. The diagnosis is the gold: ~94% of bare failures were syntax/format errors, code that never compiled, exactly the "loop" people describe, and the harness, not a smarter model, is what fixed it.
#11
@UD_eastWillow
https://x.com/UD_eastWillow/status/2071141984610496787
The most underrated application of the day: agent loop engineering for embedded hardware. He built an automated loop for an Arduino air-quality sensor where the agent safely iterates on its own firmware using a WASM emulator and headless cloud testing pipelines. That sidesteps the usual blocker, that you can't let an agent freely loop on physical hardware, by giving it a safe simulated target to hill-climb against. A real glimpse of autoresearch escaping pure software into the physical world.
https://x.com/UD_eastWillow/status/2071141984610496787
The most underrated application of the day: agent loop engineering for embedded hardware. He built an automated loop for an Arduino air-quality sensor where the agent safely iterates on its own firmware using a WASM emulator and headless cloud testing pipelines. That sidesteps the usual blocker, that you can't let an agent freely loop on physical hardware, by giving it a safe simulated target to hill-climb against. A real glimpse of autoresearch escaping pure software into the physical world.
#12
@JacobCounsell
https://x.com/JacobCounsell/status/2071263936133861594
A loop pointed at idea validation rather than code. His LaunchChair agent loop has Codex and Claude rerun new project ideas until they clear concrete thresholds: ICP pain above 90%, market saturation below 50%, wedge opportunity above 70%. The agent keeps generating and scoring until the numbers pass, so the human only sees ideas that already meet the bar. He admits the demo is boring to watch, which is rather the point of a working loop.
https://x.com/JacobCounsell/status/2071263936133861594
A loop pointed at idea validation rather than code. His LaunchChair agent loop has Codex and Claude rerun new project ideas until they clear concrete thresholds: ICP pain above 90%, market saturation below 50%, wedge opportunity above 70%. The agent keeps generating and scoring until the numbers pass, so the human only sees ideas that already meet the bar. He admits the demo is boring to watch, which is rather the point of a working loop.
#13
@luckeyfaraday
https://x.com/luckeyfaraday/status/2071172306865365064
A lightweight Python framework implementing the orchestrator-worker-reviewer pattern as a deterministic harness with a closed feedback loop. A goal is decomposed into subtasks, fanned out to worker subagents, aggregated, then run through a review gate that loops until the work meets its success criteria. It's the canonical agent-loop shape, made explicit and reusable rather than reinvented per project.
https://x.com/luckeyfaraday/status/2071172306865365064
A lightweight Python framework implementing the orchestrator-worker-reviewer pattern as a deterministic harness with a closed feedback loop. A goal is decomposed into subtasks, fanned out to worker subagents, aggregated, then run through a review gate that loops until the work meets its success criteria. It's the canonical agent-loop shape, made explicit and reusable rather than reinvented per project.
#14
@akshay_pachaar
https://x.com/akshay_pachaar/status/2071227474227482690
A methodology deep-dive on Hermes Mixture-of-Agents, which folds multi-model consultation inside the agent loop instead of outside it. The usual workaround is running a prompt through several models by hand and reconciling, but that lives outside the agent, so the tools, memory, and session are gone the moment you detour. MoA puts reference models plus an aggregator into the loop itself, so a composite of providers already on hand can outscore the best single one available. The framing, every model has blind spots the others would catch, is a clean argument for in-loop ensembling.
https://x.com/akshay_pachaar/status/2071227474227482690
A methodology deep-dive on Hermes Mixture-of-Agents, which folds multi-model consultation inside the agent loop instead of outside it. The usual workaround is running a prompt through several models by hand and reconciling, but that lives outside the agent, so the tools, memory, and session are gone the moment you detour. MoA puts reference models plus an aggregator into the loop itself, so a composite of providers already on hand can outscore the best single one available. The framing, every model has blind spots the others would catch, is a clean argument for in-loop ensembling.
#15
@OsaurusAI
https://x.com/OsaurusAI/status/2071072951122940296
A concrete recovery-loop technique: instead of giving up or blindly repeating after a failed tool call, failures are fed back to the model as structured error envelopes so it can correct course on the next turn. It's a small design choice with outsized impact on reliability, the difference between a loop that compounds its own errors and one that learns from them mid-run.
https://x.com/OsaurusAI/status/2071072951122940296
A concrete recovery-loop technique: instead of giving up or blindly repeating after a failed tool call, failures are fed back to the model as structured error envelopes so it can correct course on the next turn. It's a small design choice with outsized impact on reliability, the difference between a loop that compounds its own errors and one that learns from them mid-run.
#16
@dipankarsarkar
https://x.com/dipankarsarkar/status/2071221555162456066
A debugging insight worth more than most methodology threads: he chased a "flaky" agent loop for a while assuming it was the model, and it turned out to be his own state getting mutated between steps. Cleaning up that path removed most of the flakiness. His takeaway, a lot of what gets blamed on sampling non-determinism is just sloppy deterministic state handling, which is a useful corrective to the instinct to blame the model for loop instability.
https://x.com/dipankarsarkar/status/2071221555162456066
A debugging insight worth more than most methodology threads: he chased a "flaky" agent loop for a while assuming it was the model, and it turned out to be his own state getting mutated between steps. Cleaning up that path removed most of the flakiness. His takeaway, a lot of what gets blamed on sampling non-determinism is just sloppy deterministic state handling, which is a useful corrective to the instinct to blame the model for loop instability.
#17
@Gyome1_
https://x.com/Gyome1_/status/2071260081816215579
A hands-on tour of five open-source repos that explain agent loops better than paid courses, with the self-improving ones highlighted. GenericAgent is the smallest self-evolving agent he's seen, ~3K lines with a tiny loop and automatic skill growth; Recursive Agents shows the cleanest Draft, Critique, Revise pattern where the agent reviews its own work before answering; Loop Engineering ships production tools for detecting infinite loops and tracking token cost. The conclusion after reading them, an agent is just an LLM with memory, tools, and a loop, and once you see that, building your own is easy.
https://x.com/Gyome1_/status/2071260081816215579
A hands-on tour of five open-source repos that explain agent loops better than paid courses, with the self-improving ones highlighted. GenericAgent is the smallest self-evolving agent he's seen, ~3K lines with a tiny loop and automatic skill growth; Recursive Agents shows the cleanest Draft, Critique, Revise pattern where the agent reviews its own work before answering; Loop Engineering ships production tools for detecting infinite loops and tracking token cost. The conclusion after reading them, an agent is just an LLM with memory, tools, and a loop, and once you see that, building your own is easy.
#18
@0xPascual
https://x.com/0xPascual/status/2071258057057681450
A business-side use of an agentic loop: a CTO replaced an entire manual sprint-planning workflow with a custom loop hooked directly into the Jira API. A base prompt ingests design Figma files and outputs technical specifications, collapsing the translation-of-requirements-into-tickets work into a config and a stateless script. The stack runs on a $20 Claude API subscription and a $40/month GPU instance, replacing a three-month planning cycle with seconds of latency. Treat the savings figures as a pitch, but the workflow, an autonomous loop owning the requirements-to-tickets translation, is real.
https://x.com/0xPascual/status/2071258057057681450
A business-side use of an agentic loop: a CTO replaced an entire manual sprint-planning workflow with a custom loop hooked directly into the Jira API. A base prompt ingests design Figma files and outputs technical specifications, collapsing the translation-of-requirements-into-tickets work into a config and a stateless script. The stack runs on a $20 Claude API subscription and a $40/month GPU instance, replacing a three-month planning cycle with seconds of latency. Treat the savings figures as a pitch, but the workflow, an autonomous loop owning the requirements-to-tickets translation, is real.
#19
@Peaky8linders
https://x.com/Peaky8linders/status/2071290463441572213
A team building a cybersecurity and compliance remediation pipeline on top of a published autoresearch methodology. The core idea is living organizational context graphs spanning Slack, Notion, wikis, slides, and GitHub repos, so the remediation agents never operate in a vacuum. It's a concrete example of the autoresearch pattern, deep unified context plus an iterating agent, being ported out of pure research into an enterprise security workflow.
https://x.com/Peaky8linders/status/2071290463441572213
A team building a cybersecurity and compliance remediation pipeline on top of a published autoresearch methodology. The core idea is living organizational context graphs spanning Slack, Notion, wikis, slides, and GitHub repos, so the remediation agents never operate in a vacuum. It's a concrete example of the autoresearch pattern, deep unified context plus an iterating agent, being ported out of pure research into an enterprise security workflow.
π‘ Eco Products Radar
Eco Products Radar
Hermes (Agent): the recurring substrate for self-improving loops, agents that write and refine their own skills and run a review loop on a schedule.
Codex: the workhorse inside multiple autoresearch and idea-validation loops, often run in parallel instances.
Claude Code: the default harness people wrap their loops around, and the benchmark target SkillOpt measured gains inside.
Ollama: the local-serving layer behind the cheap verifier-loop benchmarks on consumer and DGX Spark hardware.
Hermes (Agent): the recurring substrate for self-improving loops, agents that write and refine their own skills and run a review loop on a schedule.
Codex: the workhorse inside multiple autoresearch and idea-validation loops, often run in parallel instances.
Claude Code: the default harness people wrap their loops around, and the benchmark target SkillOpt measured gains inside.
Ollama: the local-serving layer behind the cheap verifier-loop benchmarks on consumer and DGX Spark hardware.
Comments