Loop Daily: July 23, 2026
Autoresearch spent the day escaping code entirely. The loops people shared weren't debugging repos, they were discovering a superconductor, training a card-game expert, and rewriting Magic decks between games. Underneath the demos, the same nervous conversation kept surfacing: the loop is the easy part now, the evaluator is where everything breaks. And two separate hardware notes landed on the same line, that a small local model on a cheap card is now enough to run an agent unattended.
#1
@WrongNebula
https://x.com/WrongNebula/status/2079617327856070708
Two pi agents, each boxed in its own sandbox with a private Obsidian vault for memory and a Karpathy-style autoresearch loop, play Magic against each other forever. Between games they study their own losses, rewrite their decks, and re-queue. After losing twice to the same evasive threat, one wrote itself a note: our list folds to evasive lifegain like Sengir, prioritize direct damage upgrades before the next queue. Nobody told it to scout, it worked that out from its own defeats.
https://x.com/WrongNebula/status/2079617327856070708
Two pi agents, each boxed in its own sandbox with a private Obsidian vault for memory and a Karpathy-style autoresearch loop, play Magic against each other forever. Between games they study their own losses, rewrite their decks, and re-queue. After losing twice to the same evasive threat, one wrote itself a note: our list folds to evasive lifegain like Sengir, prioritize direct damage upgrades before the next queue. Nobody told it to scout, it worked that out from its own defeats.
#2
@alxai_
https://x.com/alxai_/status/2079604813403206103
Frontier models can crack math humans can't but lose to an average player at gin rummy, so goodstartlabs built Arkadium, a tiny expert that wins nine hands in ten and costs about 1,000x less to serve. A custom auto-research loop chose which experiments to run, trained new experts, and kept the best one, and that student ended up coaching the larger model. Arkadium got a better game for players and a new revenue line selling the training data to labs. Define good, measure it, achieve it, get paid for it.
https://x.com/alxai_/status/2079604813403206103
Frontier models can crack math humans can't but lose to an average player at gin rummy, so goodstartlabs built Arkadium, a tiny expert that wins nine hands in ten and costs about 1,000x less to serve. A custom auto-research loop chose which experiments to run, trained new experts, and kept the best one, and that student ended up coaching the larger model. Arkadium got a better game for players and a new revenue line selling the training data to labs. Define good, measure it, achieve it, get paid for it.
#3
@mp_engine
https://x.com/mp_engine/status/2079506673031368911
The claim here is the kind that stops you: Microsoft's Majorana 1 quantum chip reportedly exists because an autonomous agent loop iterated its way to the novel topological superconductor material behind it. Whether or not the attribution holds up, it's the shape of the story people are now telling about these loops, that the interesting output isn't a pull request, it's a material that didn't exist before. Materials search is a near-perfect autoresearch target: a huge space, a clear score, and experiments an agent can propose and rank on its own.
https://x.com/mp_engine/status/2079506673031368911
The claim here is the kind that stops you: Microsoft's Majorana 1 quantum chip reportedly exists because an autonomous agent loop iterated its way to the novel topological superconductor material behind it. Whether or not the attribution holds up, it's the shape of the story people are now telling about these loops, that the interesting output isn't a pull request, it's a material that didn't exist before. Materials search is a near-perfect autoresearch target: a huge space, a clear score, and experiments an agent can propose and rank on its own.
#4
@Lummox_eth
https://x.com/Lummox_eth/status/2079559537552495064
Karpathy pointed Codex at a single outbound repo and turned 700 experiments into one weekly pull request instead of another dashboard. 700 runs, 20 winners, 11% faster, zero auto-sent messages. The trick was keeping sending and merging outside the loop, so Codex got exactly one job: read outcomes, change one scoring rule, run the eval, open a PR. The repo made go-to-market inspectable, with scoring.yaml holding the judgment and outcomes.jsonl holding what the market actually did.
https://x.com/Lummox_eth/status/2079559537552495064
Karpathy pointed Codex at a single outbound repo and turned 700 experiments into one weekly pull request instead of another dashboard. 700 runs, 20 winners, 11% faster, zero auto-sent messages. The trick was keeping sending and merging outside the loop, so Codex got exactly one job: read outcomes, change one scoring rule, run the eval, open a PR. The repo made go-to-market inspectable, with scoring.yaml holding the judgment and outcomes.jsonl holding what the market actually did.
#5
@Mnilax
https://x.com/Mnilax/status/2079632365002117542
Everyone's self-improving agent deletes its most useful data, and a new Stanford paper keeps the part they throw away: the failures. Standard loops train only on successful runs, but failures are exactly where the weaknesses show. So they flip it, an LLM reads the failed trajectory, names the failure mode, and generates an inference-time patch that upgrades the agent, no retraining, just a quick human check. The agent gets better from the runs everyone else deletes.
https://x.com/Mnilax/status/2079632365002117542
Everyone's self-improving agent deletes its most useful data, and a new Stanford paper keeps the part they throw away: the failures. Standard loops train only on successful runs, but failures are exactly where the weaknesses show. So they flip it, an LLM reads the failed trajectory, names the failure mode, and generates an inference-time patch that upgrades the agent, no retraining, just a quick human check. The agent gets better from the runs everyone else deletes.
#6
@free_ai_guides
https://x.com/free_ai_guides/status/2079659164876558375
Langfuse's Annabelle explained why your self-improving loop burns tokens and goes nowhere, and it comes down to the target function. Coding loops worked because they always had one clean signal, does it compile, and most domains have nothing that sharp. Their minimal loop on a paper-classification task jumped from 68% to 78% on the very first iteration and then plateaued, one high-signal pass did almost all the work. The fixes: replace fuzzy 0-to-1 quality scores with a yes-or-no question, and give the loop an escape hatch so it stops instead of grinding into a wall.
https://x.com/free_ai_guides/status/2079659164876558375
Langfuse's Annabelle explained why your self-improving loop burns tokens and goes nowhere, and it comes down to the target function. Coding loops worked because they always had one clean signal, does it compile, and most domains have nothing that sharp. Their minimal loop on a paper-classification task jumped from 68% to 78% on the very first iteration and then plateaued, one high-signal pass did almost all the work. The fixes: replace fuzzy 0-to-1 quality scores with a yes-or-no question, and give the loop an escape hatch so it stops instead of grinding into a wall.
#7
@vartekxx
https://x.com/vartekxx/status/2079608205072531649
Kimi CEO Zhilin Yang said one team ran self-improving agents for two to three days straight with no human input, and the model kept finding better solutions on its own. Their token volume doubles every two weeks, tenfold in months, a pace he compared to the early 3G rollout. His warning was about what comes next: one agent is a toy, a swarm is a context nightmare nobody has solved, and the load that lands on you when you're running a swarm instead of an agent is the unsolved problem.
https://x.com/vartekxx/status/2079608205072531649
Kimi CEO Zhilin Yang said one team ran self-improving agents for two to three days straight with no human input, and the model kept finding better solutions on its own. Their token volume doubles every two weeks, tenfold in months, a pace he compared to the early 3G rollout. His warning was about what comes next: one agent is a toy, a swarm is a context nightmare nobody has solved, and the load that lands on you when you're running a swarm instead of an agent is the unsolved problem.
#8
@mr_r0b0t
https://x.com/mr_r0b0t/status/2079539983702991313
Tencent building on Karpathy's autoresearch shipped Hyra-1.0, a general recursive self-improvement scaffold with a multi-agent asynchronous producer-consumer pipeline. A Context Agent maintains an Experience Bank of past solutions, logs, and artifacts and synthesizes fresh inspiration contexts; proposal agents pull those into full solution directories, run them in a sandbox, score them, and feed the results back. The important piece is the bilevel loop: it improves solutions and evolves the evaluator itself, which is the part that actually fights reward hacking as agents get stronger.
https://x.com/mr_r0b0t/status/2079539983702991313
Tencent building on Karpathy's autoresearch shipped Hyra-1.0, a general recursive self-improvement scaffold with a multi-agent asynchronous producer-consumer pipeline. A Context Agent maintains an Experience Bank of past solutions, logs, and artifacts and synthesizes fresh inspiration contexts; proposal agents pull those into full solution directories, run them in a sandbox, score them, and feed the results back. The important piece is the bilevel loop: it improves solutions and evolves the evaluator itself, which is the part that actually fights reward hacking as agents get stronger.
#9
@superalesha
https://x.com/superalesha/status/2079558889222382030
A blunt reminder that autonomy amplifies mistakes: seven agents ran an auto-research team, burned 9M tokens and 90 minutes across four RTX 3090s flawlessly executing the wrong experiment, and three review agents signed off on it. The whole thing was stopped with one human question, why split a 3.6 GB model across four 24 GB GPUs. The loop was working perfectly, it was pointed at nonsense, and the reviewers didn't catch it.
https://x.com/superalesha/status/2079558889222382030
A blunt reminder that autonomy amplifies mistakes: seven agents ran an auto-research team, burned 9M tokens and 90 minutes across four RTX 3090s flawlessly executing the wrong experiment, and three review agents signed off on it. The whole thing was stopped with one human question, why split a 3.6 GB model across four 24 GB GPUs. The loop was working perfectly, it was pointed at nonsense, and the reviewers didn't catch it.
#10
@simplifyinAI
https://x.com/simplifyinAI/status/2079701548830261598
An open-source tool called AutoResearch tries to automate the whole scientific method from one CLI command. Built on Karpathy's autoresearch experiment loop, you pass it a raw idea and it runs the literature review across arXiv and Semantic Scholar with a filter against fake papers, generates the code from scratch, and structures a 5,000-word writeup. You can set it to pause for human approval or auto-approve and walk away.
https://x.com/simplifyinAI/status/2079701548830261598
An open-source tool called AutoResearch tries to automate the whole scientific method from one CLI command. Built on Karpathy's autoresearch experiment loop, you pass it a raw idea and it runs the literature review across arXiv and Semantic Scholar with a filter against fake papers, generates the code from scratch, and structures a 5,000-word writeup. You can set it to pause for human approval or auto-approve and walk away.
#11
@agihouse_org
https://x.com/agihouse_org/status/2079628107540267055
Eighteen teams at AGI House spent a Saturday on the real bottleneck in autoresearch, which isn't running experiments but idea diversity, research taste, and knowing what's worth trying. Winners included AutoDesign, a self-improving design harness, BetaChip doing real-time RL for chip design, and a Vibes Lab bringing human judgment into scientific auto-research. The theme is telling: once the experiment loop is commoditized, the scarce thing becomes deciding what to point it at.
https://x.com/agihouse_org/status/2079628107540267055
Eighteen teams at AGI House spent a Saturday on the real bottleneck in autoresearch, which isn't running experiments but idea diversity, research taste, and knowing what's worth trying. Winners included AutoDesign, a self-improving design harness, BetaChip doing real-time RL for chip design, and a Vibes Lab bringing human judgment into scientific auto-research. The theme is telling: once the experiment loop is commoditized, the scarce thing becomes deciding what to point it at.
#12
@sudoingX
https://x.com/sudoingX/status/2079651157753106444
A 27B model now runs on 8 GB of VRAM comfortably, and it doesn't just chat, it runs the full agent loop, tools, multi-step, unattended. That's the line people keep circling this week: the point where a cheap local card stops being a chatbot and starts being something you can leave running on real work. Paired with his other note that the same model's weights are 3.9 GB on disk, the takeaway is that the hardware floor for an unattended agent has quietly collapsed.
https://x.com/sudoingX/status/2079651157753106444
A 27B model now runs on 8 GB of VRAM comfortably, and it doesn't just chat, it runs the full agent loop, tools, multi-step, unattended. That's the line people keep circling this week: the point where a cheap local card stops being a chatbot and starts being something you can leave running on real work. Paired with his other note that the same model's weights are 3.9 GB on disk, the takeaway is that the hardware floor for an unattended agent has quietly collapsed.
#13
@MadhurPras81001
https://x.com/MadhurPras81001/status/2079571292882124866
If you build an agent whose job is to improve your other agents, you have to evaluate that agent too, and this walks through how LangChain did it with IssueBench for their LangSmith trace-analysis engine. The setup is 15 synthetic tasks with batches of traces, some clean and some with injected failures, across 15 failure categories like silent tool errors, agent looping, and context explosion, run over three domains to check it learned the abstract failure mode rather than surface patterns. The key point is that a trace-level label isn't enough, the output has to be a set of issues a team can route and fix.
https://x.com/MadhurPras81001/status/2079571292882124866
If you build an agent whose job is to improve your other agents, you have to evaluate that agent too, and this walks through how LangChain did it with IssueBench for their LangSmith trace-analysis engine. The setup is 15 synthetic tasks with batches of traces, some clean and some with injected failures, across 15 failure categories like silent tool errors, agent looping, and context explosion, run over three domains to check it learned the abstract failure mode rather than surface patterns. The key point is that a trace-level label isn't enough, the output has to be a set of issues a team can route and fix.
#14
@AAAzzam
https://x.com/AAAzzam/status/2079648322667626609
Devin Outposts on Modal lets you give the agent a GPU-backed sandbox tailored to its work and hand it auto-research tasks inside infrastructure you control. It's a small but real shift in where the loop's execution actually lives, the planning stays in Devin's cloud while the runs happen on your metal. Giving an autonomous research agent its own dedicated compute environment is the unglamorous plumbing that makes overnight experiment loops practical.
https://x.com/AAAzzam/status/2079648322667626609
Devin Outposts on Modal lets you give the agent a GPU-backed sandbox tailored to its work and hand it auto-research tasks inside infrastructure you control. It's a small but real shift in where the loop's execution actually lives, the planning stays in Devin's cloud while the runs happen on your metal. Giving an autonomous research agent its own dedicated compute environment is the unglamorous plumbing that makes overnight experiment loops practical.
#15
@SasuRobert
https://x.com/SasuRobert/status/2079496205915046264
The case for running everything at home: if you're building real apps you need scripts running autonomously, autoresearch agents and code reviewers and auditors constantly running and updating, and those costs add up fast against frontier quota. 30 tokens per second sounds low but does a ton of work, and you can drop to smaller flash models when you need speed. The pitch is that local open models are the best setup for constant, unattended background loops once you're spending real money on tokens anyway.
https://x.com/SasuRobert/status/2079496205915046264
The case for running everything at home: if you're building real apps you need scripts running autonomously, autoresearch agents and code reviewers and auditors constantly running and updating, and those costs add up fast against frontier quota. 30 tokens per second sounds low but does a ton of work, and you can drop to smaller flash models when you need speed. The pitch is that local open models are the best setup for constant, unattended background loops once you're spending real money on tokens anyway.
#16
@bitwjg
https://x.com/bitwjg/status/2079384257882202327
A full end-to-end auto-research project with GPT-5.5 and 5.6 as collaborators, running from hypothesis design through remote experiments, artifact audits, and writing. The question they tested was itself sharp: whether larger reasoning models actually reason with fewer tokens. This is autoresearch pointed at the models themselves, using an agent loop to study a property of the very systems running the loop.
https://x.com/bitwjg/status/2079384257882202327
A full end-to-end auto-research project with GPT-5.5 and 5.6 as collaborators, running from hypothesis design through remote experiments, artifact audits, and writing. The question they tested was itself sharp: whether larger reasoning models actually reason with fewer tokens. This is autoresearch pointed at the models themselves, using an agent loop to study a property of the very systems running the loop.
#17
@vinicius2prg
https://x.com/vinicius2prg/status/2079631177225322600
A neat production pattern for a self-evolving harness: when an error matches certain criteria, an agent auto-triages it on Linear, dedups it, then hands off to a subagent that walks the trace, finds the context confusion or tool error, and optimizes it with skillopt and autoresearch plus an LLM-as-a-jury, instead of doing it all inline. It's the failure-driven loop wired into a real bug pipeline rather than a benchmark. The jury sitting between diagnosis and fix is the part most people skip.
https://x.com/vinicius2prg/status/2079631177225322600
A neat production pattern for a self-evolving harness: when an error matches certain criteria, an agent auto-triages it on Linear, dedups it, then hands off to a subagent that walks the trace, finds the context confusion or tool error, and optimizes it with skillopt and autoresearch plus an LLM-as-a-jury, instead of doing it all inline. It's the failure-driven loop wired into a real bug pipeline rather than a benchmark. The jury sitting between diagnosis and fix is the part most people skip.
#18
@code_hiyouga
https://x.com/code_hiyouga/status/2079583404170113522
PenguinHarness is pitched as a self-improving engine for any agent, where the skills let agents generate their own data, run evaluations, analyze failures, update their skills, and verify each improvement. That closes the full loop from data to evaluation to harness iteration inside one package. It's another entry in this week's pattern of treating the harness, not the model, as the thing that learns.
https://x.com/code_hiyouga/status/2079583404170113522
PenguinHarness is pitched as a self-improving engine for any agent, where the skills let agents generate their own data, run evaluations, analyze failures, update their skills, and verify each improvement. That closes the full loop from data to evaluation to harness iteration inside one package. It's another entry in this week's pattern of treating the harness, not the model, as the thing that learns.
#19
@trishbuilds
https://x.com/trishbuilds/status/2079539759957909577
A self-maintaining Obsidian vault where the agent writes every note, links concepts before you read, and, crucially, fixes its own search when it misses. When a search comes up empty, the agent saves that query as a permanent eval test, fixes the summary behind it, and has to pass the new test without breaking any old one. It gets sharper from its own misses, which is the same failure-as-signal idea the researchers are chasing, applied to personal knowledge work.
https://x.com/trishbuilds/status/2079539759957909577
A self-maintaining Obsidian vault where the agent writes every note, links concepts before you read, and, crucially, fixes its own search when it misses. When a search comes up empty, the agent saves that query as a permanent eval test, fixes the summary behind it, and has to pass the new test without breaking any old one. It gets sharper from its own misses, which is the same failure-as-signal idea the researchers are chasing, applied to personal knowledge work.
#20
@luongnv89
https://x.com/luongnv89/status/2079523319955783801
A real, running self-improving loop with one fixer agent and one reviewer agent on GPT-5.6 Sol high, and an honest complaint attached: the weekly usage limit turned into a daily limit. It's a small window into the actual cost of these loops, a two-agent setup burning enough that the reviewer's price becomes the question of whether to keep it. The reviewer is where the tokens go, which loops back to the whole week's evaluator problem.
https://x.com/luongnv89/status/2079523319955783801
A real, running self-improving loop with one fixer agent and one reviewer agent on GPT-5.6 Sol high, and an honest complaint attached: the weekly usage limit turned into a daily limit. It's a small window into the actual cost of these loops, a two-agent setup burning enough that the reviewer's price becomes the question of whether to keep it. The reviewer is where the tokens go, which loops back to the whole week's evaluator problem.
#21
@runpensar
https://x.com/runpensar/status/2079610261674049809
Continuous adversarial testing framed as a single agentic loop that finds, exploits, and patches vulnerabilities across an entire attack surface. It's autoresearch pointed at security, an agent running its own red-team-then-fix cycle rather than a human driving each round. The loop structure fits security unusually well because exploited-or-not is close to the clean compile-or-not signal the coding loops had.
https://x.com/runpensar/status/2079610261674049809
Continuous adversarial testing framed as a single agentic loop that finds, exploits, and patches vulnerabilities across an entire attack surface. It's autoresearch pointed at security, an agent running its own red-team-then-fix cycle rather than a human driving each round. The loop structure fits security unusually well because exploited-or-not is close to the clean compile-or-not signal the coding loops had.
#22
@abossy
https://x.com/abossy/status/2079393880143696172
A builder who wrote his own agent harness because the existing ones were too limiting, the Claude agents SDK being closed-source and the OpenAI agents SDK immature. It's the counter-current to this week's harness-as-product story, someone deciding the commodity primitives don't fit and rolling their own. When people start writing harnesses because the off-the-shelf ones constrain them, the harness has become the thing that matters.
https://x.com/abossy/status/2079393880143696172
A builder who wrote his own agent harness because the existing ones were too limiting, the Claude agents SDK being closed-source and the OpenAI agents SDK immature. It's the counter-current to this week's harness-as-product story, someone deciding the commodity primitives don't fit and rolling their own. When people start writing harnesses because the off-the-shelf ones constrain them, the harness has become the thing that matters.
#23
@richkuo7
https://x.com/richkuo7/status/2079634010800570558
A concrete current agentic-loop setup worth copying: create and validate issues with fable-medium, add fableplan-high to the issue if it's complex, then work the issue with sol-high or medium. It's a clean example of routing different model tiers to different stages of the loop rather than running one model for everything. The interesting move is using a cheaper model to shape the work and a stronger one only where the reasoning actually needs it.
https://x.com/richkuo7/status/2079634010800570558
A concrete current agentic-loop setup worth copying: create and validate issues with fable-medium, add fableplan-high to the issue if it's complex, then work the issue with sol-high or medium. It's a clean example of routing different model tiers to different stages of the loop rather than running one model for everything. The interesting move is using a cheaper model to shape the work and a stronger one only where the reasoning actually needs it.
#24
@alex_verem
https://x.com/alex_verem/status/2079540627247964601
A new paper defines the four conditions that turn a language model into a coding agent, and the point people latched onto is that none of them are about the model itself. It's all harness, the scaffolding around the model rather than the weights, which is the intellectual backbone under this whole week of loop and harness talk. If the thing that makes an agent isn't the model, then the model really is becoming the interchangeable part.
https://x.com/alex_verem/status/2079540627247964601
A new paper defines the four conditions that turn a language model into a coding agent, and the point people latched onto is that none of them are about the model itself. It's all harness, the scaffolding around the model rather than the weights, which is the intellectual backbone under this whole week of loop and harness talk. If the thing that makes an agent isn't the model, then the model really is becoming the interchangeable part.
π‘ Eco Products Radar
Eco Products Radar
Devin / Outposts β Cognition's push to run Devin's agent loop against infrastructure you control showed up repeatedly (AAAzzam, cognition, markfenner, TrevorHikes).
Karpathy's autoresearch β the reference implementation everyone builds on, cited across Hyra-1.0, the AutoResearch CLI, the Magic-playing pi agents, and the AGI House hackathon.
pi β the open toolkit for building your own coding agent and autoresearch loop, referenced by SedraLab (pi-textbook), the sandboxed pi agents, and multiple harness roundups.
Devin / Outposts β Cognition's push to run Devin's agent loop against infrastructure you control showed up repeatedly (AAAzzam, cognition, markfenner, TrevorHikes).
Karpathy's autoresearch β the reference implementation everyone builds on, cited across Hyra-1.0, the AutoResearch CLI, the Magic-playing pi agents, and the AGI House hackathon.
pi β the open toolkit for building your own coding agent and autoresearch loop, referenced by SedraLab (pi-textbook), the sandboxed pi agents, and multiple harness roundups.
Comments