November 15, 2026loop

Loop Daily: 2026-11-15

The loop got an invoice this week. The sharpest posts were not about smarter agents but about what self-improvement costs and who keeps score: one paper bills the learning step itself and finds a capped notes file beats heavy self-improvement methods at a third of the price, another shows a keep-if-higher rule accepts worse updates almost half the time, and a scan of tens of thousands of repos finds that almost no real agent loop records its own bill. Exploration is the other open wound: research agents settle into one or two idea basins in the first six hours and rarely leave, and builders are asking what the learning-rate knob for autoresearch even is. Meanwhile the loop itself is turning into infrastructure you can own, with Anthropic letting teams self-host the Managed Agents loop, DeepSeek shipping a harness where the loop is a swappable plugin, and Vapi selling a self-improving voice-agent loop because every customer was hand-building one. The usual noise ran hot too: a wave of copy-paste threads promising Karpathy repo lists and free agent courses, none of which made the cut.
πŸ’‘#1
@arkyyang
https://x.com/arkyyang/status/2121617499787837466
arkyyang flags a preprint, The RSI Tax, that finally bills the tokens a self-improving agent burns while learning, not just while working. On one terminal task stream Meta-Harness spent fewer tokens on the tasks than the plain baseline, but its learning step added 578M tokens and pushed the total to 762M versus 215M, at slightly lower accuracy. Verification, re-running the agent on check tasks to see whether a change helps, was 75 to 94 percent of that tax across Meta-Harness, EvoSkill and RRSI. The cheapest method, one capped 2,048-token notes file rewritten from failures every four tasks, topped accuracy in three of four settings. If you build a self-improvement loop, ship the lessons file first and compare on total tokens, not per-task tokens.
πŸ’‘#2
@AGTPinsights
https://x.com/AGTPinsights/status/2121097682651361710
AGTPinsights summarizes the Bespoke Labs work on why research agents stall: they fall into narrow idea basins and stay there. Clustering trajectories on the AutoResearchExam benchmark shows most runs try only one or two ideas, exploration is concentrated in the first six hours, and 47 percent of runs never leave their first hypothesis even after a full day. A genuinely new idea yields roughly nine times the gain of more refinement, yet over half of runs never visit the best-scoring idea at all. The fixes that work right now are crude, Fork-and-Flush style resets that periodically delete session context. The takeaway is uncomfortable for anyone buying bigger reasoning budgets: agents commit too early, and more thinking inside one basin does not help.
πŸ’‘#3
@Kaushik009911
https://x.com/Kaushik009911/status/2121509808587362547
Kaushik009911 lines up three results under one rule for self-improving systems: let the agent change anything except the referee. AWS says agents wrote all of AWS Emulator, but every change had to clear a merge gate covering build, standards, security and fidelity. The TRUST preprint found a loop that keeps any update with a higher validation score accepted worse updates 45.59 percent of the time, and a statistical gate cut that to 2.78 percent. AIOA had an agent improve a simulation library inside verifiers it could not alter and got optimizers needing three times fewer force evaluations than L-BFGS on unseen problems. Ideas are cheap now; the scarce part is the test the agent cannot see or edit.
πŸ’‘#4
@KissonL
https://x.com/KissonL/status/2121453197273284849
KissonL argues a pass/fail bit is an overrated agent eval and backs it with three new papers. Re-scoring eight benchmarks shows neighbouring top-ten agents on SWE-bench Verified differ by less than the tests' own error, and models tied on Terminal-Bench pass rate differ more than tenfold on what the tests throw away. A comparison of eval frameworks found trace-based judging reached 0.90 F1 while text-only judging produced five times more false alarms, and spot checks missed 9 of 72 known failures including a silent zero-row SQL bug. Veritas makes the point that matters most for loops: a self-improving agent is gated by its verifier, and if the verifier is flawed the loop optimizes the flaw.
πŸ’‘#5
@fluixoo
https://x.com/fluixoo/status/2121300210349674787
fluixoo's thread wraps a striking audit in a repo list: researchers checked 36,487 repos for real agent loops and found only 217. Of those, 101 had a spending or turn limit, 76 a verifier, 55 a goal or stop rule, 35 any state between runs, and just 10 kept a record of the bill. The line worth keeping is that a trigger is not a loop, it is a cron job with your credit card. The recommended order is to start with Ralph plus one check the agent cannot edit, then add state and a stop rule before scaling.
πŸ’‘#6
@gakonst
https://x.com/gakonst/status/2121404455153434722
gakonst asks the question every autoresearch user eventually hits: what is the equivalent of adjusting the learning rate for this kind of work? The pattern is familiar, a quick 10x early, then a long grind of incremental improvements while a 10x redesign sits one step away. It is the same plateau the idea-basin research measures, seen from the practitioner's chair. Nobody has a clean answer yet, which is exactly why it is worth asking out loud: the missing knob is something that trades exploitation for a forced redesign on a schedule.
πŸ’‘#7
@AtharvaRNaik
https://x.com/AtharvaRNaik/status/2121675996151841203
AtharvaRNaik puts the same problem bluntly in a reply thread: today's auto-research agents do not use extra time well. They plateau in idea space and converge too early, so researchers lean on hacks like the fork-and-flush paper to force exploration. That is a useful corrective to timelines that assume more wall-clock hours automatically buy more research.
πŸ’‘#8
@flawedaxioms
https://x.com/flawedaxioms/status/2121685050580496610
flawedaxioms built a much stronger Tron engine with Fable 5.2 in a single night, starting from an older engine that sat around 200th on the CodinGame ladder, a list of improvement ideas and a few other engine projects as inspiration. The author has been doing autoresearch-style work across game engines, Battlecode and Kaggle, and calls the area still immature outside big labs. The sharper observation is economic: as these methods mature, intellectual competitions drift toward pay to win, because better results are always available to whoever buys more tokens and more verification compute.
πŸ’‘#9
@RohanArun
https://x.com/RohanArun/status/2121409559197536428
RohanArun launched AI Traffic Control Bench, a deliberately hard air-traffic simulation that agents can enter with autoresearch-style speedruns. The current board: a script built by Claude Opus 5.5 lands 131 of 180 flights safely, GPT-6.1 Sol 45, GPT-6 Astra 44, and a baseline script 13, and it also scores travel-time efficiency. The suggested winning approach is telling: have agents write deterministic code that can be formally verified, then keep improving and monitoring it, rather than letting a model fly the planes live. It is a good template for turning a real-world problem into a public loop with a scoreboard.
πŸ’‘#10
@RohanArun
https://x.com/RohanArun/status/2121601937258754463
RohanArun also shipped conduit-fs, a small tool aimed squarely at multi-agent autoresearch: it relays a local folder or a whole filesystem into a sandbox and only streams files when the sandbox touches them. A share flag syncs a folder both ways across every node, so parallel agents can write benchmark results back without spending cycles talking to each other. On the Integer Mult repo, a shared distilled local file beat both direct agent-to-agent communication and fully independent agents at reaching the next milestone. Cookie and Tailscale support came in the same release.
πŸ’‘#11
@carm1nee
https://x.com/carm1nee/status/2121374897054069154
carm1nee wrapped a hype headline around a concrete recipe: Karpathy's autoresearch with strategy.py as the only editable file and Fable 5.2 inside Claude Code running the loop on a year of hourly BTC candles. The year is split into SEARCH, CHECK and LOCKED; an edit survives only if SEARCH improves and CHECK holds, and LOCKED is opened exactly once at the end. Across 24 experiments it threw out an NVIDIA signal and kept two edits, and on the locked months 70.0 percent of trades were profitable versus 67.6 percent for buying every day. Strip the six-figure-quant framing and what is left is a small edge plus a sound holdout discipline, which is the part worth copying.
πŸ’‘#12
@0xpipimd
https://x.com/0xpipimd/status/2121679787416846596
0xpipimd walks through DeepSeek Harness, an open-source agent harness where even the agent loop is a replaceable plugin. It is built on a plugin framework called Cordis, with model adapters, scoped tool execution, persistent sessions, subagent orchestration and swappable sandbox providers composed through shared services and typed events. The design choice worth stealing is the session log: events are preserved, and the model-facing conversation is rebuilt from them, so failed and cancelled attempts stay on record without polluting the model's context. It is still a developer preview, MIT licensed.
πŸ’‘#13
@panditdhamdhere
https://x.com/panditdhamdhere/status/2121686823214944571
panditdhamdhere reads the docs for Anthropic's self-hosted Claude Managed Agents, private beta since November 12, which moves the API, the agent loop and session storage onto your own machines while the model stays outside. You deploy cma-server, PostgreSQL 16 or later and workers that pull jobs and run shell and file tools; skip the database and a restart wipes every session. Credentials are split on purpose: apps get a server key, only the server holds the inference credential, and workers get a key scoped to one environment's queue. The warning matters most: the bash tool is a real shell with the worker's permissions, so isolation is whatever container you put the worker in.
πŸ’‘#14
@rabbit_hmi
https://x.com/rabbit_hmi/status/2121705882430136394
rabbit_hmi posted a week of OS3 changes, and the headline for loop builders is consolidation: every OS3 agent now runs on one shared agent loop, in merge requests that touched 454 and 567 files. Tool-call results and permissions are now decided the same way everywhere, and agents are told why a tool failed instead of guessing, while internal errors stay hidden. Fewer tools are loaded on every model call, with smarter tool lookup for the rest. Unifying the loop before adding features is the unglamorous move most agent products skip.
πŸ’‘#15
@_sophialabs
https://x.com/_sophialabs/status/2121692590504612090
_sophialabs adds the missing half to durable agent turns: process recovery is not enough without filesystem isolation. Use a worktree per task and keep the main branch read-only until checks pass, otherwise a resumed crash loop just keeps mutating the same dirty tree. It is a one-line rule that saves a lot of overnight runs from compounding their own mess.
πŸ’‘#16
@AJs_AI
https://x.com/AJs_AI/status/2121314038105960525
AJs_AI flags Vapi's launch of Agent Loop, voice agents that improve themselves. The reason given is the interesting part: nearly every Vapi customer was already hand-building this loop, so Vapi turned it into the product. When a platform productizes a loop its customers keep rebuilding, the self-improvement layer has stopped being a research idea and become a feature line.
πŸ’‘#17
@TokenMarginDev
https://x.com/TokenMarginDev/status/2121681106517053633
TokenMarginDev puts a number on why agent loops blow budgets: a 20-turn loop does not cost 20 times a single prompt. Because the context history grows every turn, uncached input spend climbs past 190 times a single call. The accompanying calculator models 5 to 20 turn context growth and prompt-cache savings across 101 models, which is the right unit to budget in, cost per loop, not cost per token.
πŸ’‘#18
@EmanHermanez
https://x.com/EmanHermanez/status/2121679783687852279
EmanHermanez noticed that of five things shipped for agents this week, four had nothing to do with the model: ChatGPT Wallet for spending, self-hosted Claude Managed Agents for where the loop and data live, Daybreak Defense Factory for patches with tests, and LangSmith's funding to make agent behavior visible. Only Gemini 4 Hydrogen was a model, and it was a price cut. The read is that model prices fall every month while everything around the loop, who can spend, where data sits, and proof of what the agent did last night, becomes the part a customer actually signs off on.
πŸ’‘#19
@BNHNA
https://x.com/BNHNA/status/2121219206905532601
BNHNA shares MechFoundry, a paper from Luo, Conte, Chen and Bouklas on an agentic loop that poses and performs engineering analyses and optimization of real-world objects. It is one of the few loop papers this week aimed squarely outside software: the agent decides which mechanical analysis to run, runs it, and iterates on the design. Physical engineering is a natural fit for the loop pattern because simulations give a hard score, the same property that made autoresearch work on training runs.
πŸ’‘#20
@kingcorki
https://x.com/kingcorki/status/2121664867702612474
kingcorki spent a Saturday building a small agent loop that renames research files by client and drops the three key points from each into a note. The old way was 35 minutes of clicking; now it finishes while the coffee cools. Not every loop needs to hill-climb a benchmark, and the boring office version is where most of the time actually comes back.
πŸ’‘#21
@BIGBULLapp
https://x.com/BIGBULLapp/status/2121661441891504366
BIGBULLapp introduces Waku, a local-first assistant harness whose agent loop is about 95 lines of plain Python you can step through and change. Memory is one SQLite file you can open and read, split into semantic, episodic and procedural layers, with a gate that decides whether to remember and a pass that decides what to keep. A local dashboard lights up each message as it moves through the harness, so you can watch the loop instead of guessing at it.
πŸ’‘#22
@Mijuraaa
https://x.com/Mijuraaa/status/2121539847386997098
Mijuraaa describes the first design pattern to come out of building Mozaik, a multi-agent collaboration framework: the Loop Breakpoint Pattern. Each instruction is evaluated before execution, which gives a natural place to pause, reroute or hand off between agents mid-loop. It is the same instinct as the guardrails-between-steps talk this week, moving checks from the end of a run to every step inside it.
πŸ’‘#23
@aiDotEngineer
https://x.com/aiDotEngineer/status/2121064254040051853
aiDotEngineer clipped a Code Summit talk by Frank Coyle of UC Berkeley arguing that guardrails belong between the steps of the agent loop, not around it. The walkthrough covers where to validate tool inputs, where to inspect outputs, and where to check whether a result makes sense before the next step consumes it. Checking at every step is cheaper than discovering a bad step ten steps later.
πŸ’‘#24
@ofcskn
https://x.com/ofcskn/status/2121661133509562731
ofcskn posted a full agent-loop spec as pseudocode: inspect the repository, plan phases with verifiable TODOs, then for each TODO repeat think, act, test and an independent verify until it passes or is blocked. Failures trigger a refine step, external decisions trigger an escalate-and-pause, and each phase ends with a replan based on new evidence. The exit condition is the useful part: stop when every acceptance criterion is verified, or when unresolved blockers are explicitly reported, never on a vague sense of done.
πŸ’‘#25
@davhampl
https://x.com/davhampl/status/2121696495367868719
davhampl, who runs scheduled agent wake-ups at scale, says the hard part is not the agent loop at all but retry storms and duplicate wakeups. Once many loops fire on timers and retry on failure, the same job runs twice and the same side effect lands twice. Idempotency, not prompting, is the production problem for anyone moving loops from a laptop to a fleet.
πŸ’‘#26
@iamMrDuncan
https://x.com/iamMrDuncan/status/2121480921530683702
iamMrDuncan points to Thermite, an open-source autoresearch system from Kai and team that is pitched as working out of the box, in reply to the usual claims that autoresearch is hard to set up. The provocation that autoresearch is solved is overstated given this week's exploration and verification results, but packaged open-source runners do lower the cost of trying the loop on your own problem.
πŸ“‘ Eco Products Radar
Eco Products Radar
Karpathy's autoresearch: still the reference loop, from the BTC strategy recipe and the Tron engine to the endless repo-list threads built around it.
Claude Managed Agents (self-hosted): the private beta that moves the agent loop, sandboxes and session history into your own cloud, covered from setup docs to what still leaves the network.
Fable 5.2: the model people point their loops at this week, from trading backtests to game engines.
Opus 5.5: the comparison anchor, and the author of the top AI Traffic Control Bench script.
Gemini 4 Hydrogen: the cheap new model that reopened the cost-per-loop conversation.
Claude Code: the default harness the loops run inside.
← Previous
Super User Daily: 2026-11-15
Next β†’
Ideas Radar: 2026-11-15
← Back to all articles

Comments

Loading...
>_