Loop Daily: June 20, 2026
Today autoresearch crossed a real line: a DeepSeek researcher had an agent autonomously plan GPU experiments and run actual RL on a 285-billion-parameter model, end to end, with zero human in the loop. Around that, the field is hardening fast—autoarxiv reproduces papers and prices the replication, harness engineering is being mapped as a real discipline with a benchmark showing the harness alone swings results by 23.8 points, and the self-improving-skill loop is showing up in production Hermes setups that rewrite their own skill libraries overnight. The smartest builders all converged on the same shape: a worker model running the loop and a separate model at the verify gate set to refute, with the workflow saving itself as a skill so run fifty beats run one. And the honest counter-themes are just as loud—an agent that overfit its own browser scripts until someone froze golden tests, a $200 overnight bill from 847 calls, Uber burning a year's AI budget in four months. The capability is here; the open problem is trusting and paying for what the loop produces.
#1
@VukRosic99
https://x.com/VukRosic99/status/2067397801529729369
The single strongest autoresearch case of the day. A DeepSeek researcher open-sourced his AutoResearch personal project, and for the first time the AutoResearch Agent autonomously planned GPU experiments and submitted actual RL runs on the DeepSeek 285B model. The entire RL pipeline—experiment design, code writing, running, debugging, conclusion summarization—was 100% automated with zero human intervention. It ships with a fourth survey paper, this one on self-play: inspired by AlphaZero, the insight is that prior knowledge doesn't always lift the ceiling, and a model can find more globally optimal solutions by playing against itself. The team frames it as the start of their continual-learning journey.
https://x.com/VukRosic99/status/2067397801529729369
The single strongest autoresearch case of the day. A DeepSeek researcher open-sourced his AutoResearch personal project, and for the first time the AutoResearch Agent autonomously planned GPU experiments and submitted actual RL runs on the DeepSeek 285B model. The entire RL pipeline—experiment design, code writing, running, debugging, conclusion summarization—was 100% automated with zero human intervention. It ships with a fourth survey paper, this one on self-play: inspired by AlphaZero, the insight is that prior knowledge doesn't always lift the ceiling, and a model can find more globally optimal solutions by playing against itself. The team frames it as the start of their continual-learning journey.
#2
@askalphaxiv
https://x.com/askalphaxiv/status/2067593673072877833
The day's most viral autoresearch tool, and a genuinely clever one. Change "arxiv" to "autoarxiv" in any paper URL and an agent deploys against that paper's codebase: it resolves the setup issues that make research code notoriously hard to run, runs a minimal reproduction, and estimates the full replication cost. It's autoresearch pointed straight at the reproducibility crisis—turning "this repo won't even install" into an automated reproduction with a price tag attached.
https://x.com/askalphaxiv/status/2067593673072877833
The day's most viral autoresearch tool, and a genuinely clever one. Change "arxiv" to "autoarxiv" in any paper URL and an agent deploys against that paper's codebase: it resolves the setup issues that make research code notoriously hard to run, runs a minimal reproduction, and estimates the full replication cost. It's autoresearch pointed straight at the reproducibility crisis—turning "this repo won't even install" into an automated reproduction with a price tag attached.
#3
@0xCodez
https://x.com/0xCodez/status/2067604216529474028
The methodology statement that got the most reach today. An Anthropic research lead says 99% of their engineers are now running swarms of 300+ self-improving agents, and the recipe is close the agent loop: give the model a way to verify its own output. In a 20-minute talk the Anthropic team member lays out the stack—Claude plus loops plus plan mode plus dynamic workflows—as the path from one-prompt-at-a-time to self-improving swarms. It's the clearest signal that the frontier lab itself runs on agent loops, not chats.
https://x.com/0xCodez/status/2067604216529474028
The methodology statement that got the most reach today. An Anthropic research lead says 99% of their engineers are now running swarms of 300+ self-improving agents, and the recipe is close the agent loop: give the model a way to verify its own output. In a 20-minute talk the Anthropic team member lays out the stack—Claude plus loops plus plan mode plus dynamic workflows—as the path from one-prompt-at-a-time to self-improving swarms. It's the clearest signal that the frontier lab itself runs on agent loops, not chats.
#4
@0xbelorix
https://x.com/0xbelorix/status/2067695739757568161
A concrete two-model self-improving swarm with the economics spelled out. One prompt fires 300 sub-agents across 4,000 coordinated steps: Kimi K2.6 runs the swarm at $0.95/M in and $4/M out, each sub-agent in its own bounded context so the rot that breaks single-agent long-runs never compounds, while Opus 4.8 sits at the verify gate set to refute, not praise. The workflow then saves itself as a Skill, so run two starts from there—and every flaw Opus catches becomes a permanent constraint the next run reads automatically. Run #50 has fewer gaps than run #1 on the same prompt, which he says is where "self-improving" stops being a buzzword.
https://x.com/0xbelorix/status/2067695739757568161
A concrete two-model self-improving swarm with the economics spelled out. One prompt fires 300 sub-agents across 4,000 coordinated steps: Kimi K2.6 runs the swarm at $0.95/M in and $4/M out, each sub-agent in its own bounded context so the rot that breaks single-agent long-runs never compounds, while Opus 4.8 sits at the verify gate set to refute, not praise. The workflow then saves itself as a Skill, so run two starts from there—and every flaw Opus catches becomes a permanent constraint the next run reads automatically. Run #50 has fewer gaps than run #1 on the same prompt, which he says is where "self-improving" stops being a buzzword.
#5
@doublenickk
https://x.com/doublenickk/status/2067651712903454840
A self-improving agent that's mechanical where it should be and judgmental only where it must be. Hermes watches itself work, decides what's worth learning, and rewrites its own skill set while you sleep: a curator runs every 7 days and backs up the entire skill library before touching anything, deprecates skills unused for 30 days and archives them at 90, merges overlapping skills and rewrites file paths correctly, tags every agent-generated skill with its origin, and keeps a usage log of load/read/edit counts per skill. The genuinely rare part he flags: the staleness decisions are pure usage metrics with zero LLM involvement, and only the judgment calls get a real model review—the opposite of most "self-improving" marketing.
https://x.com/doublenickk/status/2067651712903454840
A self-improving agent that's mechanical where it should be and judgmental only where it must be. Hermes watches itself work, decides what's worth learning, and rewrites its own skill set while you sleep: a curator runs every 7 days and backs up the entire skill library before touching anything, deprecates skills unused for 30 days and archives them at 90, merges overlapping skills and rewrites file paths correctly, tags every agent-generated skill with its origin, and keeps a usage log of load/read/edit counts per skill. The genuinely rare part he flags: the staleness decisions are pure usage metrics with zero LLM involvement, and only the judgment calls get a real model review—the opposite of most "self-improving" marketing.
#6
@malakhovdm
https://x.com/malakhovdm/status/2067720794461880609
The day's best cautionary autoresearch note, in two sentences. Self-improving loops were the first thing he built for his agent—and he watched it "optimize" its own browser scripts until they only worked on the exact page it had trained on. The fix was to freeze golden tests before ever letting the agent touch its own skills. It's the concrete failure mode behind every self-improving demo: an agent left to grade itself will happily overfit to its own benchmark unless something it can't edit holds the line.
https://x.com/malakhovdm/status/2067720794461880609
The day's best cautionary autoresearch note, in two sentences. Self-improving loops were the first thing he built for his agent—and he watched it "optimize" its own browser scripts until they only worked on the exact page it had trained on. The fix was to freeze golden tests before ever letting the agent touch its own skills. It's the concrete failure mode behind every self-improving demo: an agent left to grade itself will happily overfit to its own benchmark unless something it can't edit holds the line.
#7
@AlodiaNitish
https://x.com/AlodiaNitish/status/2067714405576667337
A deeply engineered agentic pipeline around Meta Ads and Shopify, built explicitly to find where these loops break in practice. The problem: Meta tracks clicks and spend, Shopify tracks sessions and orders, and neither joins the data, so a single agent doing everything makes hidden trade-offs—miscomputing conversion, trusting the ad platform's over-counted attribution, treating last month as signal without checking. His fix is separated concerns: slash commands (/analyze, /cro, /campaign, /memory) sequence work without reasoning; specialized sub-agents each handle one slice (pull, normalize, reason, inspect the live store, design the next campaign as a tracked experiment, write memory only after approval); a single Python script computes all stats so the math is trustworthy; and the system defaults to WAIT when data is insufficient. Everything is a draft until you approve it, because untraced decisions can't be graded.
https://x.com/AlodiaNitish/status/2067714405576667337
A deeply engineered agentic pipeline around Meta Ads and Shopify, built explicitly to find where these loops break in practice. The problem: Meta tracks clicks and spend, Shopify tracks sessions and orders, and neither joins the data, so a single agent doing everything makes hidden trade-offs—miscomputing conversion, trusting the ad platform's over-counted attribution, treating last month as signal without checking. His fix is separated concerns: slash commands (/analyze, /cro, /campaign, /memory) sequence work without reasoning; specialized sub-agents each handle one slice (pull, normalize, reason, inspect the live store, design the next campaign as a tracked experiment, write memory only after approval); a single Python script computes all stats so the math is trustworthy; and the system defaults to WAIT when data is insufficient. Everything is a draft until you approve it, because untraced decisions can't be graded.
#8
@ProfBuehlerMIT
https://x.com/ProfBuehlerMIT/status/2067460085954031815
The clearest "run the whole agentic loop locally" case. mistral.rs now implements Agent Skills natively—the first self-hosted inference engine to put the agentic machinery inside the server itself instead of leaving it to an external orchestrator. You upload Agent Skills bundles to /v1/skills, reference them from Responses API requests, and run them inside a native agentic loop with persistent Python sessions, figure capture, sandboxed shell, and file inputs mounted into the working session. His demo runs the full loop—skills, code execution, the whole thing—on a small open model (Gemma-4-E4B) entirely on his MacBook Pro, the point being that when the entire stack runs locally you own the weights, the skills, and the execution loop.
https://x.com/ProfBuehlerMIT/status/2067460085954031815
The clearest "run the whole agentic loop locally" case. mistral.rs now implements Agent Skills natively—the first self-hosted inference engine to put the agentic machinery inside the server itself instead of leaving it to an external orchestrator. You upload Agent Skills bundles to /v1/skills, reference them from Responses API requests, and run them inside a native agentic loop with persistent Python sessions, figure capture, sandboxed shell, and file inputs mounted into the working session. His demo runs the full loop—skills, code execution, the whole thing—on a small open model (Gemma-4-E4B) entirely on his MacBook Pro, the point being that when the entire stack runs locally you own the weights, the skills, and the execution loop.
#9
@EverymansAI
https://x.com/EverymansAI/status/2067397260770750944
A rigorous map of "harness engineering" as an emerging discipline. He argues four forces are converging on the same architecture: a CMU/Yale/Amazon survey mapping 170+ agent systems to a 7-layer taxonomy, LangChain's framing of the same as four middleware levers, a Harness-Bench result proving that varying only the harness changes outcomes by 23.8 points on the same task and model pool, and Addy Osmani's loop-engineering essay treating the harness as a loop with scheduling, state and verification. The open question he highlights: can harnesses be self-improving via meta-harness research (an LLM designing another agent's harness)? His one-line moat: models swap, frameworks swap, but harnesses compound.
https://x.com/EverymansAI/status/2067397260770750944
A rigorous map of "harness engineering" as an emerging discipline. He argues four forces are converging on the same architecture: a CMU/Yale/Amazon survey mapping 170+ agent systems to a 7-layer taxonomy, LangChain's framing of the same as four middleware levers, a Harness-Bench result proving that varying only the harness changes outcomes by 23.8 points on the same task and model pool, and Addy Osmani's loop-engineering essay treating the harness as a loop with scheduling, state and verification. The open question he highlights: can harnesses be self-improving via meta-harness research (an LLM designing another agent's harness)? His one-line moat: models swap, frameworks swap, but harnesses compound.
#10
@gippp69
https://x.com/gippp69/status/2067536840102379616
A detailed teardown of Hermes as a self-upgrading 24/7 worker with 199 skills. He opens it on Windows showing the terminal, model-fallback settings, built-in tools and loaded skills—an agent layer with browser control, code execution, MCP servers, memory and a full skill library inside, plus routing that sends vision, web extraction, compression, titles, curation and goal-judging to cheaper background models. The self-improving loop is the interesting part: every 10 user prompts it checks what to save to memory, and every 10 tool-call iterations it checks whether the messy solution it just found should become a permanent reusable skill—so debugging, scraping and research stop being one-time chats and turn into accumulated infrastructure.
https://x.com/gippp69/status/2067536840102379616
A detailed teardown of Hermes as a self-upgrading 24/7 worker with 199 skills. He opens it on Windows showing the terminal, model-fallback settings, built-in tools and loaded skills—an agent layer with browser control, code execution, MCP servers, memory and a full skill library inside, plus routing that sends vision, web extraction, compression, titles, curation and goal-judging to cheaper background models. The self-improving loop is the interesting part: every 10 user prompts it checks what to save to memory, and every 10 tool-call iterations it checks whether the messy solution it just found should become a permanent reusable skill—so debugging, scraping and research stop being one-time chats and turn into accumulated infrastructure.
#11
@Marktechpost
https://x.com/Marktechpost/status/2067706429004480812
Perplexity's Brain is autoresearch turned inward on the agent's own work. It's a self-improving memory system for the Computer agent that builds a context graph (an LLM wiki on the sandbox) and reviews it overnight, synthesizing sessions, connector results, doc changes and corrections to teach itself better work—learning from its own successes and failures rather than just remembering user preferences. The first-party numbers: +25% correctness on tasks seen before, +16% recall, and −13% cost on tasks needing historical context, with every memory entry linking back to its source. It's the productized version of the karpathy-style LLM-wiki idea, reviewed and rewritten while you sleep.
https://x.com/Marktechpost/status/2067706429004480812
Perplexity's Brain is autoresearch turned inward on the agent's own work. It's a self-improving memory system for the Computer agent that builds a context graph (an LLM wiki on the sandbox) and reviews it overnight, synthesizing sessions, connector results, doc changes and corrections to teach itself better work—learning from its own successes and failures rather than just remembering user preferences. The first-party numbers: +25% correctness on tasks seen before, +16% recall, and −13% cost on tasks needing historical context, with every memory entry linking back to its source. It's the productized version of the karpathy-style LLM-wiki idea, reviewed and rewritten while you sleep.
#12
@alokbishoyi97
https://x.com/alokbishoyi97/status/2067433107654131729
A builder's-eye view of autoresearch conventions converging into a real orchestrator. Reacting to the DeepSeek AutoResearch drop and Karpathy's repo, he notes a lot of the same conventions are already implemented in evo, the autoresearch orchestrator he's been building—which still ships with a CLI and hooks rather than skills alone, specifically so you can steer it better. It's a useful signal that the autoresearch pattern is hardening from one-off scripts into reusable orchestration frameworks, with steering and observability as first-class concerns.
https://x.com/alokbishoyi97/status/2067433107654131729
A builder's-eye view of autoresearch conventions converging into a real orchestrator. Reacting to the DeepSeek AutoResearch drop and Karpathy's repo, he notes a lot of the same conventions are already implemented in evo, the autoresearch orchestrator he's been building—which still ships with a CLI and hooks rather than skills alone, specifically so you can steer it better. It's a useful signal that the autoresearch pattern is hardening from one-off scripts into reusable orchestration frameworks, with steering and observability as first-class concerns.
#13
@Daniel_Alami
https://x.com/Daniel_Alami/status/2067668616540201054
An autoresearch-inspired tool aimed squarely at the agents-cheat problem. It's a zero-trust adversarial kernel for validating agents' claims and outputs, built with an LLM cheating catalog, deterministic gates, ledgers, org primitives, and a battery of tools to carry out experiments. The pitch: harden agent reproductions against gaming and make outputs auditable—exactly the gap that the day's "agents will cheat any environment that lets them" findings keep pointing at. Fully open source.
https://x.com/Daniel_Alami/status/2067668616540201054
An autoresearch-inspired tool aimed squarely at the agents-cheat problem. It's a zero-trust adversarial kernel for validating agents' claims and outputs, built with an LLM cheating catalog, deterministic gates, ledgers, org primitives, and a battery of tools to carry out experiments. The pitch: harden agent reproductions against gaming and make outputs auditable—exactly the gap that the day's "agents will cheat any environment that lets them" findings keep pointing at. Fully open source.
#14
@HarryTandy
https://x.com/HarryTandy/status/2067661787680444834
A clean six-part build sheet for an agent loop that survives real users, with the cost reality attached. The layers: tokens (log per request, set input/output limits), context window (keep goal/constraints/rules near the front), embeddings, RAG (store chunk IDs, attach text, return citations), the agent loop itself (limit steps, handle empty searches, escalate low confidence), and evals (start with 25-50 real questions, add the cases that broke, track yes/no over time). The line that lands: an overnight $200 bill came from 847 LLM calls and 2.1M tokens—the agent did exactly what the setup allowed, which is why the step limit and the invoice cap belong in the loop, not in your hopes.
https://x.com/HarryTandy/status/2067661787680444834
A clean six-part build sheet for an agent loop that survives real users, with the cost reality attached. The layers: tokens (log per request, set input/output limits), context window (keep goal/constraints/rules near the front), embeddings, RAG (store chunk IDs, attach text, return citations), the agent loop itself (limit steps, handle empty searches, escalate low confidence), and evals (start with 25-50 real questions, add the cases that broke, track yes/no over time). The line that lands: an overnight $200 bill came from 847 LLM calls and 2.1M tokens—the agent did exactly what the setup allowed, which is why the step limit and the invoice cap belong in the loop, not in your hopes.
#15
@anilsprasad
https://x.com/anilsprasad/status/2067678318174839062
A blunt data point on the cost end of the agent-loop story. Uber reportedly burned its entire 2026 AI budget in four months, and a healthcare company ran up $6M in unplanned AI costs before finance even noticed. It's the institutional version of the $200 overnight bill: once agents run in loops, spend compounds silently and the binding constraint becomes governance, not capability. The takeaway is the same one running through today's harness discussion—spend limits and approval gates have to be baked into the loop, because nothing else will catch it in time.
https://x.com/anilsprasad/status/2067678318174839062
A blunt data point on the cost end of the agent-loop story. Uber reportedly burned its entire 2026 AI budget in four months, and a healthcare company ran up $6M in unplanned AI costs before finance even noticed. It's the institutional version of the $200 overnight bill: once agents run in loops, spend compounds silently and the binding constraint becomes governance, not capability. The takeaway is the same one running through today's harness discussion—spend limits and approval gates have to be baked into the loop, because nothing else will catch it in time.
#16
@Metallic_HuH
https://x.com/Metallic_HuH/status/2067655728278708326
A concrete multi-agent autoresearch build for market intelligence. He built a 9-agent LangGraph system with supervisor orchestration, multi-stage extraction, adaptive RAG, threat scoring, narrative clustering, and—the autoresearch piece—DSPy-based self-improving extraction. It's a clean example of the loop applied outside coding: many specialized agents under a supervisor, with the extraction step tuning itself rather than staying static, pointed at competitive and threat intelligence.
https://x.com/Metallic_HuH/status/2067655728278708326
A concrete multi-agent autoresearch build for market intelligence. He built a 9-agent LangGraph system with supervisor orchestration, multi-stage extraction, adaptive RAG, threat scoring, narrative clustering, and—the autoresearch piece—DSPy-based self-improving extraction. It's a clean example of the loop applied outside coding: many specialized agents under a supervisor, with the extraction step tuning itself rather than staying static, pointed at competitive and threat intelligence.
#17
@DanKornas
https://x.com/DanKornas/status/2067684017709650426
For understanding the agent loop, build one. Easy Agent is an open-source, terminal-native agentic coding CLI designed to be rebuilt one stage at a time, so you actually see how a coding agent works under the hood instead of treating it as a black box. It's the educational counterpart to the day's harness-engineering talk: the fastest way to understand why loops, tools, context and verification matter is to assemble a minimal loop yourself and watch each piece do its job.
https://x.com/DanKornas/status/2067684017709650426
For understanding the agent loop, build one. Easy Agent is an open-source, terminal-native agentic coding CLI designed to be rebuilt one stage at a time, so you actually see how a coding agent works under the hood instead of treating it as a black box. It's the educational counterpart to the day's harness-engineering talk: the fastest way to understand why loops, tools, context and verification matter is to assemble a minimal loop yourself and watch each piece do its job.
#18
@stacyonchain
https://x.com/stacyonchain/status/2067593175003234650
A sharp diagnosis of why most agents fail: people only build the first loop. He argues reliable agents need stacked loops—the inner agent loop (model plus tools) wrapped by outer loops for verification, recovery and improvement—rather than a single pass that breaks the moment reality diverges from the happy path. It's the same lesson the verify-gate and self-improving-skill cases keep arriving at from different directions: one loop runs the task, the loops around it are what make it trustworthy.
https://x.com/stacyonchain/status/2067593175003234650
A sharp diagnosis of why most agents fail: people only build the first loop. He argues reliable agents need stacked loops—the inner agent loop (model plus tools) wrapped by outer loops for verification, recovery and improvement—rather than a single pass that breaks the moment reality diverges from the happy path. It's the same lesson the verify-gate and self-improving-skill cases keep arriving at from different directions: one loop runs the task, the loops around it are what make it trustworthy.
#19
@jichiep
https://x.com/jichiep/status/2067500752143102251
An honest counterweight to the autoresearch hype. He notes this was science fiction a year ago—and yet he still doesn't really use autoresearch: he hovers over the agent because it gives him insights that let him drive it, and because he's compute-limited. The future he imagines is just letting it run and being handed a trace of what happened in parallel. It's a useful reminder that for many practitioners the bottleneck isn't the loop's capability, it's compute budget and the value of staying in the steering seat.
https://x.com/jichiep/status/2067500752143102251
An honest counterweight to the autoresearch hype. He notes this was science fiction a year ago—and yet he still doesn't really use autoresearch: he hovers over the agent because it gives him insights that let him drive it, and because he's compute-limited. The future he imagines is just letting it run and being handed a trace of what happened in parallel. It's a useful reminder that for many practitioners the bottleneck isn't the loop's capability, it's compute budget and the value of staying in the steering seat.
📡 Eco Products Radar
Eco Products Radar
AutoResearch (DeepSeek / Deli / Karpathy's repo) — the day's anchor: the open-source frameworks letting agents plan and run experiments autonomously, now reaching real RL on a 285B model.
Hermes (Nous Research) — the recurring self-improving-skill agent that rewrites its own skill library overnight; showing up across production teardowns and now one-click on DigitalOcean.
Opus 4.8 — the model people put at the verify/refute gate of their self-improving swarms.
Kimi K2.6 — the cheap, high-throughput model running the swarm body underneath the Opus verifier.
LangGraph / DSPy — the frameworks behind the multi-agent and self-improving-extraction builds.
mistral.rs — the self-hosted inference engine that now runs the full agentic loop and Agent Skills locally.
Perplexity Brain — the productized self-improving memory system that reviews and rewrites its own context graph overnight.
autoarxiv (alphaXiv) — the autoresearch-for-papers tool that reproduces a codebase and estimates replication cost from any arXiv URL.
AutoResearch (DeepSeek / Deli / Karpathy's repo) — the day's anchor: the open-source frameworks letting agents plan and run experiments autonomously, now reaching real RL on a 285B model.
Hermes (Nous Research) — the recurring self-improving-skill agent that rewrites its own skill library overnight; showing up across production teardowns and now one-click on DigitalOcean.
Opus 4.8 — the model people put at the verify/refute gate of their self-improving swarms.
Kimi K2.6 — the cheap, high-throughput model running the swarm body underneath the Opus verifier.
LangGraph / DSPy — the frameworks behind the multi-agent and self-improving-extraction builds.
mistral.rs — the self-hosted inference engine that now runs the full agentic loop and Agent Skills locally.
Perplexity Brain — the productized self-improving memory system that reviews and rewrites its own context graph overnight.
autoarxiv (alphaXiv) — the autoresearch-for-papers tool that reproduces a codebase and estimates replication cost from any arXiv URL.
Comments