Loop Daily: July 16, 2026

@zhengyaojiang
https://x.com/zhengyaojiang/status/2077079778793042425
The clearest RSI result of the day. His team built AIDE2, a system with two autoresearch loops: an inner loop that optimizes code against an eval like any normal autoresearch agent, and an outer loop that optimizes the inner loop's own harness code against average scores across benchmarks. Running autoresearch on the autoresearch agent for eight days produced a harness that beats the one they hand-tuned for two years on held-out benchmarks. Fully autonomously it designed a novel search algorithm, cut prompt size 16x, and built a layered defense against reward hacking.

@yuxiangwu_
https://x.com/yuxiangwu_/status/2077087643922260354
The same AIDE story from the builder's seat, and the honest part is what lands. Two years of hand-tuning AIDE, and AIDE2 tried much of the same literature in 100 unattended steps: island genetic algorithms, MCTS backups, restart policies. It rejected nearly all of it and beat the team with a few simple mechanisms they never thought to combine. His words: humbling to be out-researched by your own agent, RSI is here at Level 1.

@NVIDIAAI
https://x.com/NVIDIAAI/status/2077061428998013279
The most viral concrete demo. They gave a coding agent a goal and a time budget: build a training environment and teach a vision model to count colored stars. Using autoresearch with NeMo RL, NeMo Gym, and reusable skills, the agent set up, trained, and evaluated the model while the researcher only steered at a high level. Qwen3-VL-2B went from 25% to 96.9% accuracy in about five hours, and the agent proposed the next experiment on its own.

@anshuc
https://x.com/anshuc/status/2077173469293535723
A no-ML-background user trained a 1.7B local autocorrect model that beats GPT-5.6 Sol, for $0. Inspired by Karpathy's autoresearch, he ran Codex /goal with a loop that picks an experiment, tries it, records results, throws out failures, and plans the next without repeating mistakes. Sol independently shortlisted base models, built a keyboard-physics typo simulator, swapped a broken tokenizer for T5Gemma, wrote a custom byte-aligned loss, and added beam search with prefix streaming. Final error-reduction rate: 91.02% versus Apple's 49.66% and Sol's own 90.56%.

@CalvinGrunewald
https://x.com/CalvinGrunewald/status/2076861793910301140
A grounded list of where autoresearch-style loops actually paid off in his work. He used it to cut CI test time (measure a number, keep changes that improve it), burn down lint and anything else identifiable by inspecting the AST, drive a planner that generates a detailed task list then loops author/test/commit per task, and run bug-hunting QA where every 30 minutes it does a manual test pass, finds bugs, and fixes them.

@ishaangtwt
https://x.com/ishaangtwt/status/2077125412631838846
A month of near-fully-autonomous shipping, 80k+ lines where 99% was AI-written. The standout is AutoRalph, which combines Ralph loops with Karpathy's autoresearch into a long-running autonomous system meant to operate for weeks without unnecessary token burn. Alongside it he shipped a Slack-native autonomous agent, a production RAG over 10M+ docs, and a Claude-to-Cloudflare-Workers-AI bridge, mostly using Devin CLI plus tmux and worktrees for hands-off runs.

@askalphaxiv
https://x.com/askalphaxiv/status/2077054667868217556
A concrete recipe for turning a paper into a reproducible artifact via autoresearch. The agent first focuses on doing autoresearch to reproduce an illustrating experiment from the paper, then assembles a notebook with interactive visualizations built from the prior experiments' artifacts, and when possible adds a GPU cell that runs a lightweight example from scratch.

@samaneggs
https://x.com/samaneggs/status/2076987708858302940
A sharp methodological warning most autoresearch setups ignore. If every gain immediately funds more search, a lucky seed can become a whole research direction on noise. His project Rockie reserves compute for replication before expanding a promising branch, and keeps reproduction runs, environment changes, and branch decisions in one shared evidence trail so you can tell dependence from real progress.

@morgymcg
https://x.com/morgymcg/status/2076919105769140645
A clean framing of why autoresearch is not just long-running coding. Writing and testing code is cheap and fast, but ML experiments take hours, days, or weeks, so researchers stay far more involved in curating and steering an autoresearch programme than they would a coding task. His bet: the implementations that succeed will be the ones that deliberately keep the researcher in the loop.

@Vtrivedy10
https://x.com/Vtrivedy10/status/2077078004581171207
A deep, practitioner-level thread on running auto-research loops over real trace data. He covers closing the sim2real gap using repo access plus user context instead of traces alone, building categories of verifiers from existing benchmarks so the generating agent doesn't go off the rails, and treating harness engineering from traces as an optimization problem grounded in evals rather than vibes. He runs this with a tool called Engine, mapping trace issues back to PRs and testing changes against evals.

@ostg_
https://x.com/ostg_/status/2077071184894583106
A practical starter stack for a self-improving system, distilled from an NVIDIA roadmap. The key structural change is an independent verifier sub-agent instead of self-critique, since a model loves defending its own reasoning while a separate verifier does not. He pairs it with a five-stage memory system (Fail, Investigate, Verify, Distill, Consult) anchored in a STATE.md file every session reads and updates, plus model tiering that routes routine work to cheaper models and saves the expensive one for high-stakes blocks.

@qurisage
https://x.com/qurisage/status/2077035387050926397
Hard numbers on the verifier-versus-self-critique question. Running a Fable 5 self-improving loop, he reports the independent-verifier setup delivering roughly a 6x pipeline gain over letting the model critique itself, which is exactly the structural point everyone is converging on this week.

@shaincodes
https://x.com/shaincodes/status/2077015254496879099
A non-coding self-improving loop with a clean before/after. He set up a relay loop that graded an investor deck, iterated on it, and pushed the score from 65 to 100 with no human in the loop, showing the same autoresearch machinery works on pitch material, not just ML benchmarks.

@EverymansAI
https://x.com/EverymansAI/status/2076830430465315292
Building a self-improving meta-harness that loops over its own tools. The system runs synthesis and audit tools built on ModelFusion, then improves the harness that orchestrates them, an outer-loop-over-tooling pattern that mirrors the AIDE2 structure at a smaller scale.

@Zaigennnn
https://x.com/Zaigennnn/status/2077098302105849884
A self-improving loop built on Hermes with an explicit memory-and-skill design. Memory and skill triggers fire during runs, and a seven-day curator methodology decides what gets promoted into long-term skills, so the agent's capabilities compound over a week rather than resetting each session.

@Lummox_eth
https://x.com/Lummox_eth/status/2077041237689852115
A self-improving eval loop wrapped around Replit Agent. It runs a benchmark called ViBench, feeds Telescope-detected failures back as PRs, and A/B tests the changes, closing the loop from failure detection to code change to measured improvement without manual triage.

@DkingYooo18516
https://x.com/DkingYooo18516/status/2076918847286968681
An arena approach to self-improving coding agents. Albedo pits agents against each other with adversarial evaluation over 12M trajectories, using competition rather than a fixed eval to surface which agent variants actually improve.

@ManevaAI
https://x.com/ManevaAI/status/2077060836691005738
Self-improving agents on a factory floor, not a benchmark. Running in production, the agents drove a 16x improvement in defect-stoppage, one of the clearest examples this week of the autoresearch loop applied to physical operations instead of software.

@Even64875237590
https://x.com/Even64875237590/status/2076863943734095985
A detailed self-improving architecture aimed at physical AGI. It closes a loop across SIMA-style embodied agents, Cosmos world models, active inference, and PDDL planning, sketching how a self-improvement loop would run over a robot's perception, planning, and action rather than over code.

@OpenWorldsAI
https://x.com/OpenWorldsAI/status/2077049628399112697
A self-improving trading agent harness meant to deploy across real markets. The pitch is a single autonomous loop that adapts its own strategy, extending the autoresearch pattern into live financial decision-making.

@archiexzzz
https://x.com/archiexzzz/status/2077050365661601961
A self-improving harness for live markets trained on fleet reasoning traces. Instead of one agent learning alone, it distills the reasoning traces of a whole fleet into an improved harness, a data-flywheel take on market autoresearch.

@Dipper_pol
https://x.com/Dipper_pol/status/2077095201026244866
A two-hour unattended cyber-investigation agent from Outtake, with the lesson framed as harness-over-prompt. The interesting part is operational: letting an agent loop autonomously through a security investigation for hours and finding that the harness design, not clever prompting, is what keeps it on track.

@omarsar0
https://x.com/omarsar0/status/2077058236847444005
A continuous model-agent loop driving a world model. He reports a stable 60-minute run across 20 scenes, where the agent and the generative world model stay coupled in a loop long enough to matter, a hard stability result for long-horizon generation.

@kojott
https://x.com/kojott/status/2077140944885895648
Distilled rules from running an agent loop at scale. He ran the same loop roughly 70x across six production codebases and boiled the experience down to three rules, the kind of hands-on operating knowledge that only shows up after you've watched a loop succeed and fail many times.

@TeamIDElab
https://x.com/TeamIDElab/status/2077064713981084056
Bare-metal loop engineering on old hardware. He got nex-n2-mini running around 20 tokens/sec on old K80 cards with a custom engine and custom harness running eight n2-minis at once, and is now working on the agent loop and a ternary PTQ to make quantization less lossy. A reminder that the loop lives on top of a real inference stack you sometimes have to build yourself.

@joshuamschultz
https://x.com/joshuamschultz/status/2076841457537765730
A custom ERP agentic loop and harness that prioritizes control and security. Rather than hand the keys to a general agent, he built a tighter, more controllable loop for enterprise data and can still use OpenClaw or Hermes as a proxy underneath, a pragmatic take for teams that can't run an open-ended agent against production systems.

@yuma_1_or
https://x.com/yuma_1_or/status/2076976232290455627
LOGOS, a framework for a verifiable human-agent loop. It sits over Codex and OpenHands and adds verification so a human-in-the-loop self-improvement cycle produces checkable results rather than unverified claims of progress.

@QCXINT_
https://x.com/QCXINT_/status/2076983479917772842
DorkAgent, an open-source LLM agent loop that automates Google Dorking for recon. Built on CrewAI, it turns a manual security-research chore into an autonomous loop, another example of the loop pattern landing in a specific non-generic workflow.