Loop Daily: June 18, 2026
Autoresearch left the sandbox today and walked into the physical world. NVIDIA's GEAR lab handed 8 coding agents a fleet of real robots, a GPU budget and a token budget, then stepped away β and the lab now self-improves overnight while humans read the morning reports. That single event reframes the whole field: the loop is no longer about tuning a hyperparameter, it's about an agent rewriting algorithms, reward functions and even safety controllers against a score, on hardware, unsupervised. Around it, the practical edge keeps showing up as economics and discipline β a full autoresearch loop running 48 hours for under a dollar on a cached cheaper backend, hard-won lessons on why environment-reset and 3D understanding break these loops, and a healthy contrarian reminder that the builders who ship are obsessed with verification and memory, not swarms.
#1
@DrJimFan
https://x.com/DrJimFan/status/2066921736369766762
The day's defining autoresearch event: NVIDIA's GEAR lab gave 8 Codex agents a fleet of real robots, a GPU allocation, and a generous token budget, then stepped away. The robots look for visual clues, reset the scene, practice novel skills, read papers online, debate, reflect, get stuck and try again β directly on hardware. ENPIRE solves high-precision tasks like tying zip-ties and seating GPUs all by itself, and discovered a 'physical scaling' law where 8 parallel robots improve far faster than fewer. As DrJimFan puts it, a part of the lab now self-improves overnight and they just read the reports in the morning. This is Karpathy's autoresearch crossing from bits into atoms.
https://x.com/DrJimFan/status/2066921736369766762
The day's defining autoresearch event: NVIDIA's GEAR lab gave 8 Codex agents a fleet of real robots, a GPU allocation, and a generous token budget, then stepped away. The robots look for visual clues, reset the scene, practice novel skills, read papers online, debate, reflect, get stuck and try again β directly on hardware. ENPIRE solves high-precision tasks like tying zip-ties and seating GPUs all by itself, and discovered a 'physical scaling' law where 8 parallel robots improve far faster than fewer. As DrJimFan puts it, a part of the lab now self-improves overnight and they just read the reports in the morning. This is Karpathy's autoresearch crossing from bits into atoms.
#2
@_wenlixiao
https://x.com/_wenlixiao/status/2066913063090135372
The technical core of ENPIRE, and the part worth studying. For many robotics tasks, resetting the environment is easier than the task itself, so the agents first build an auto-reset environment via Code-as-Policy, then write a heuristic reward function, sandbox it, and launch autoresearch against the score. Echoing Karpathy, this is real autoresearch β not tuning a hyperparameter or one code block, but exploring different paradigms from across the internet and rewriting anything that helps: algorithm, training objective, even the data loader. In one pin-insertion run an agent wrote its own contact-force safety controller, which beat tuning RL params.
https://x.com/_wenlixiao/status/2066913063090135372
The technical core of ENPIRE, and the part worth studying. For many robotics tasks, resetting the environment is easier than the task itself, so the agents first build an auto-reset environment via Code-as-Policy, then write a heuristic reward function, sandbox it, and launch autoresearch against the score. Echoing Karpathy, this is real autoresearch β not tuning a hyperparameter or one code block, but exploring different paradigms from across the internet and rewriting anything that helps: algorithm, training objective, even the data loader. In one pin-insertion run an agent wrote its own contact-force safety controller, which beat tuning RL params.
#3
@HaoruXue
https://x.com/HaoruXue/status/2066925773374836776
A clear framing of why this matters: ENPIRE treats physical autoresearch as an ultra-long-horizon problem and lets frontier coding agents fully evolve robotics research in the real world β propose ideas, run experiments on physical robots, auto-reset, analyze results, iterate, all in a continuous hill-climbing loop with no human in it. What started as a task has become autonomous evolution. He argues the real leap will come from natively agentic robotics models that carry the agency to gather context, follow checklists, generate actions and self-verify inside one model.
https://x.com/HaoruXue/status/2066925773374836776
A clear framing of why this matters: ENPIRE treats physical autoresearch as an ultra-long-horizon problem and lets frontier coding agents fully evolve robotics research in the real world β propose ideas, run experiments on physical robots, auto-reset, analyze results, iterate, all in a continuous hill-climbing loop with no human in it. What started as a task has become autonomous evolution. He argues the real leap will come from natively agentic robotics models that carry the agency to gather context, follow checklists, generate actions and self-verify inside one model.
#4
@bqbrady
https://x.com/bqbrady/status/2067009533030084951
The most useful skeptic in the thread. He tried building a system like ENPIRE months ago to have a robot arm play chess, and shares hard-won limits: the task-reset step is non-trivially hard to build (sometimes as hard as the task), most LLMs have weak 3D understanding and will smash objects or drive the gripper through the ground, and Claude would often move the arm into an invalid state and spend 10-20 minutes recovering. His conclusion: today's models aren't strong enough for set-and-forget hill climbing, but with enough scaffolding you can get it learning.
https://x.com/bqbrady/status/2067009533030084951
The most useful skeptic in the thread. He tried building a system like ENPIRE months ago to have a robot arm play chess, and shares hard-won limits: the task-reset step is non-trivially hard to build (sometimes as hard as the task), most LLMs have weak 3D understanding and will smash objects or drive the gripper through the ground, and Claude would often move the arm into an invalid state and spend 10-20 minutes recovering. His conclusion: today's models aren't strong enough for set-and-forget hill climbing, but with enough scaffolding you can get it learning.
#5
@SOntheotherside
https://x.com/SOntheotherside/status/2066912290369102131
A rare honest look at what running autoresearch unsupervised actually feels like day to day. His longest, easiest goals are autoresearch with minimax (or any model), which can run unsupervised for 5+ hours; on harder tasks he doesn't trust it fully and glances over the work to catch loops, stalls, or semantic bugs. One goal can span 10 minutes to days, with all work done by AI. He's even hitting the real failure modes β a semantic workflow bug where the agent only partially implemented the plan, turning a 0.2s validation into 45s.
https://x.com/SOntheotherside/status/2066912290369102131
A rare honest look at what running autoresearch unsupervised actually feels like day to day. His longest, easiest goals are autoresearch with minimax (or any model), which can run unsupervised for 5+ hours; on harder tasks he doesn't trust it fully and glances over the work to catch loops, stalls, or semantic bugs. One goal can span 10 minutes to days, with all work done by AI. He's even hitting the real failure modes β a semantic workflow bug where the agent only partially implemented the plan, turning a 0.2s validation into 45s.
#6
@arora_mrinaal
https://x.com/arora_mrinaal/status/2066758628405871097
The token-economics case of the day. He shifted his autoresearch loop to DeepSeek v4 Pro purely because of Codex limits and API costs, and the numbers are striking: almost 37M tokens over the last 48 hours, of which 95.78% of billable input tokens were cache hits, for a total estimated cost of $0.969. That's a working autoresearch loop running near-continuously for under a dollar β concrete proof that caching plus a cheaper backend can make the loop genuinely affordable.
https://x.com/arora_mrinaal/status/2066758628405871097
The token-economics case of the day. He shifted his autoresearch loop to DeepSeek v4 Pro purely because of Codex limits and API costs, and the numbers are striking: almost 37M tokens over the last 48 hours, of which 95.78% of billable input tokens were cache hits, for a total estimated cost of $0.969. That's a working autoresearch loop running near-continuously for under a dollar β concrete proof that caching plus a cheaper backend can make the loop genuinely affordable.
#7
@THUTeamEureka
https://x.com/THUTeamEureka/status/2066911229785112932
A new open-source autoresearch tool worth knowing: EurekAgent, an agent for metric-driven tasks. You give it a problem, an evaluator and a budget, and it orchestrates Claude Code sessions to propose, test, and push beyond the current SOTA inside a bounded sandbox, with secure evaluation and you in control. Free and open-source. This is the EurekAgent-style 'give it a metric and a budget, let it climb' pattern packaged so others can run it.
https://x.com/THUTeamEureka/status/2066911229785112932
A new open-source autoresearch tool worth knowing: EurekAgent, an agent for metric-driven tasks. You give it a problem, an evaluator and a budget, and it orchestrates Claude Code sessions to propose, test, and push beyond the current SOTA inside a bounded sandbox, with secure evaluation and you in control. Free and open-source. This is the EurekAgent-style 'give it a metric and a budget, let it climb' pattern packaged so others can run it.
#8
@jonasgeiping
https://x.com/jonasgeiping/status/2066924718892924948
An autoresearch result with a sharp twist. He updated Claudini, an autoresearch setup where agents autonomously improve jailbreak algorithms, and reports that Kimi-2.6 has entirely caught up β surpassing Opus 4.6 on this task. Kimi 2.6 turns out to be a strong and persistent attacker. Beyond the model-ranking headline, it's a clean example of using an autonomous improvement loop as a live benchmark of how relentlessly different models can self-optimize an adversarial objective.
https://x.com/jonasgeiping/status/2066924718892924948
An autoresearch result with a sharp twist. He updated Claudini, an autoresearch setup where agents autonomously improve jailbreak algorithms, and reports that Kimi-2.6 has entirely caught up β surpassing Opus 4.6 on this task. Kimi 2.6 turns out to be a strong and persistent attacker. Beyond the model-ranking headline, it's a clean example of using an autonomous improvement loop as a live benchmark of how relentlessly different models can self-optimize an adversarial objective.
#9
@alokbishoyi97
https://x.com/alokbishoyi97/status/2066930050952507656
A reminder that autoresearch tooling isn't only coming from the big labs. Responding to ENPIRE, this builder notes he's been tinkering in autoresearch himself and open-sourced an auto-research orchestrator that already has solid usage β over 20,000 developers. He's specifically curious how it would hold up on robotics, since few from that field have used it. Worth tracking as part of the fast-growing open autoresearch-orchestrator ecosystem.
https://x.com/alokbishoyi97/status/2066930050952507656
A reminder that autoresearch tooling isn't only coming from the big labs. Responding to ENPIRE, this builder notes he's been tinkering in autoresearch himself and open-sourced an auto-research orchestrator that already has solid usage β over 20,000 developers. He's specifically curious how it would hold up on robotics, since few from that field have used it. Worth tracking as part of the fast-growing open autoresearch-orchestrator ecosystem.
#10
@editxshub
https://x.com/editxshub/status/2066849823777841206
A crisp distillation of the overnight-autoresearch workflow that already exists if you assemble it: your new role is to write program.md, and the agent does the rest. Firecrawl pulls papers and converts them to LLM-ready data, AutoResearch runs experiments overnight at roughly 12/hour (~100 while you sleep), and Claude synthesizes what actually improved the model. You write the direction; the agent runs the loop; you wake up to results. Most people just haven't assembled the pipeline yet.
https://x.com/editxshub/status/2066849823777841206
A crisp distillation of the overnight-autoresearch workflow that already exists if you assemble it: your new role is to write program.md, and the agent does the rest. Firecrawl pulls papers and converts them to LLM-ready data, AutoResearch runs experiments overnight at roughly 12/hour (~100 while you sleep), and Claude synthesizes what actually improved the model. You write the direction; the agent runs the loop; you wake up to results. Most people just haven't assembled the pipeline yet.
#11
@mdeng34
https://x.com/mdeng34/status/2066959806393700552
A thoughtful counter-position to ENPIRE worth reading alongside it. He agrees big parts of robot-training decisions should be delegated to autoresearch, but argues the open question is in what environment training happens and how to decide when to train, deploy, and retrain. His group's bet: fully autonomous agents should recursively self-improve inside a world-model-based simulator to capture the factors of variation, with a learned 'configurator' deciding when to train versus serve. Detailed in their 'Critique of Agent Model' paper.
https://x.com/mdeng34/status/2066959806393700552
A thoughtful counter-position to ENPIRE worth reading alongside it. He agrees big parts of robot-training decisions should be delegated to autoresearch, but argues the open question is in what environment training happens and how to decide when to train, deploy, and retrain. His group's bet: fully autonomous agents should recursively self-improve inside a world-model-based simulator to capture the factors of variation, with a learned 'configurator' deciding when to train versus serve. Detailed in their 'Critique of Agent Model' paper.
#12
@zhodonx
https://x.com/zhodonx/status/2066881957112283529
The clearest beginner-to-builder explainer of agentic loops this cycle. It opens with the line from Claude Code's creator β "I don't prompt Claude anymore. My job is to write loops" β then lays out the anatomy: output becomes input through five stages (discover, plan, execute, verify, iterate), and a real loop needs four parts: a written stop condition the machine can score, a separate checker (the agent that did the work never grades its own homework), memory so run 47 knows what runs 1-46 tried, and isolation so parallel agents don't overwrite each other. Loops exist because one agent in a long session gets lazy, grades itself kindly, and drifts.
https://x.com/zhodonx/status/2066881957112283529
The clearest beginner-to-builder explainer of agentic loops this cycle. It opens with the line from Claude Code's creator β "I don't prompt Claude anymore. My job is to write loops" β then lays out the anatomy: output becomes input through five stages (discover, plan, execute, verify, iterate), and a real loop needs four parts: a written stop condition the machine can score, a separate checker (the agent that did the work never grades its own homework), memory so run 47 knows what runs 1-46 tried, and isolation so parallel agents don't overwrite each other. Loops exist because one agent in a long session gets lazy, grades itself kindly, and drifts.
#13
@analogalok
https://x.com/analogalok/status/2067023350866796962
A hardware-meets-agents experiment with a real architecture lesson. He ran a full 31B dense model (Gemma 4) on an 8GB-VRAM gaming laptop at ~3 tok/s β too slow for chat, but he argues slow isn't useless. The pattern: a fast orchestrator model (a 26B MoE at 25+ tok/s) handles routing, simple queries, tool calls and memory β the junior dev β while the 31B dense is the senior, called only when the fast model hits a wall on hard reasoning. The agentic loop stays fast; only the hard hops touch the big model. Plus overnight batch jobs and silent background code-audit loops where output quality beats speed.
https://x.com/analogalok/status/2067023350866796962
A hardware-meets-agents experiment with a real architecture lesson. He ran a full 31B dense model (Gemma 4) on an 8GB-VRAM gaming laptop at ~3 tok/s β too slow for chat, but he argues slow isn't useless. The pattern: a fast orchestrator model (a 26B MoE at 25+ tok/s) handles routing, simple queries, tool calls and memory β the junior dev β while the 31B dense is the senior, called only when the fast model hits a wall on hard reasoning. The agentic loop stays fast; only the hard hops touch the big model. Plus overnight batch jobs and silent background code-audit loops where output quality beats speed.
#14
@stagedhappen
https://x.com/stagedhappen/status/2066933841638691105
A concrete fix for a fundamental agentic-loop flaw: most agent loops are blind, breaking the moment the agent needs an asset it can't produce. DotCode rearchitected both halves of act-observe. Observe is now rendered, not read β it paints the page, refreshes, and works against the actual visual result of its last change instead of a log line describing it. Act is now generative β when the frontend references media that doesn't exist, it synthesizes the asset in-loop instead of stalling, and the whole cycle stays sealed inside their privacy boundary with no third-party egress.
https://x.com/stagedhappen/status/2066933841638691105
A concrete fix for a fundamental agentic-loop flaw: most agent loops are blind, breaking the moment the agent needs an asset it can't produce. DotCode rearchitected both halves of act-observe. Observe is now rendered, not read β it paints the page, refreshes, and works against the actual visual result of its last change instead of a log line describing it. Act is now generative β when the frontend references media that doesn't exist, it synthesizes the asset in-loop instead of stalling, and the whole cycle stays sealed inside their privacy boundary with no third-party egress.
#15
@b12
https://x.com/b12/status/2066971438968631526
A useful market snapshot of which loops people are actually running. The most popular in their directory right now: Superpowers (brainstorming, TDD, and subagent-driven dev loops), Hermes Agent (a self-improving agent with memory), autoresearch (runs experiments overnight, keeps only what works), and learn-claude-code (a ~30-line agent harness, "bash is all you need"). It's a small but telling map of where the loop ecosystem's attention sits β half coding workflows, half autonomous-improvement loops.
https://x.com/b12/status/2066971438968631526
A useful market snapshot of which loops people are actually running. The most popular in their directory right now: Superpowers (brainstorming, TDD, and subagent-driven dev loops), Hermes Agent (a self-improving agent with memory), autoresearch (runs experiments overnight, keeps only what works), and learn-claude-code (a ~30-line agent harness, "bash is all you need"). It's a small but telling map of where the loop ecosystem's attention sits β half coding workflows, half autonomous-improvement loops.
#16
@hugobowne
https://x.com/hugobowne/status/2066686628077473819
The contrarian voice the autoresearch hype needs. After 10 hours interviewing 16 Python, data, ML and AI builders he trusts about what they actually use, he found them obsessed with verification, memory, review, personal software and workflow design β and much less obsessed with swarms, autonomous loops, and agent frameworks. "Forget agent skills, forget subagents, forget OpenClaw, forget autoresearch, forget ralph loops," he writes, then points at what serious builders keep coming back to. A healthy reality check against assuming everyone is running overnight loops.
https://x.com/hugobowne/status/2066686628077473819
The contrarian voice the autoresearch hype needs. After 10 hours interviewing 16 Python, data, ML and AI builders he trusts about what they actually use, he found them obsessed with verification, memory, review, personal software and workflow design β and much less obsessed with swarms, autonomous loops, and agent frameworks. "Forget agent skills, forget subagents, forget OpenClaw, forget autoresearch, forget ralph loops," he writes, then points at what serious builders keep coming back to. A healthy reality check against assuming everyone is running overnight loops.
π‘ Eco Products Radar
Eco Products Radar
ENPIRE β NVIDIA GEAR's physical-autoresearch harness; 8 Codex agents driving a real robot fleet with no human in the loop.
autoresearch (Karpathy) β the overnight experiment-loop pattern everyone is now porting, including to robots and qualitative science.
EurekAgent β open-source autoresearch agent that orchestrates Claude Code sessions to push past SOTA on metric-driven tasks.
Claudini β autoresearch setup where agents autonomously improve jailbreak algorithms, now used to benchmark models (Kimi-2.6 vs Opus 4.6).
DeepSeek v4 Pro β the cheap, heavily-cached backend making continuous loops cost cents.
Firecrawl β papers-to-LLM-ready-data feeding the program.md β overnight-experiments pipeline.
Superpowers / Hermes Agent β the most-run loops in the open directory (dev loops; self-improving agent with memory).
ENPIRE β NVIDIA GEAR's physical-autoresearch harness; 8 Codex agents driving a real robot fleet with no human in the loop.
autoresearch (Karpathy) β the overnight experiment-loop pattern everyone is now porting, including to robots and qualitative science.
EurekAgent β open-source autoresearch agent that orchestrates Claude Code sessions to push past SOTA on metric-driven tasks.
Claudini β autoresearch setup where agents autonomously improve jailbreak algorithms, now used to benchmark models (Kimi-2.6 vs Opus 4.6).
DeepSeek v4 Pro β the cheap, heavily-cached backend making continuous loops cost cents.
Firecrawl β papers-to-LLM-ready-data feeding the program.md β overnight-experiments pipeline.
Superpowers / Hermes Agent β the most-run loops in the open directory (dev loops; self-improving agent with memory).
Comments