November 16, 2026loop

Loop Daily: 2026-11-16

The best loop builders this weekend were busy slowing their loops down. HumanLayer runs one procedure a day with at most one open PR and a sensor the agent cannot silence, a repo census finds that well under one percent of projects claiming autonomous loops actually close one, and a self-improving agent that kept updates whenever the score ticked up turned out to be accepting worse versions almost half the time. The counterweight is real money spent on real loops: four thousand dollars of tokens to teach a voice-controlled football team when to press, a compounding writing skill tuned by autoresearch to eighty percent of its author's taste, and an ops loop that turned a forty-minute morning chore into seven minutes of reviewing flags. Self-hosted Managed Agents kept drawing close readings of what still leaves the building. The noise was louder than the signal: a fresh wave of copy-paste threads built on Dario, Schmidt and Alexandr Wang clips, Karpathy repo lists and one-prompt agent cards, none of which made the cut.
πŸ’‘#1
@RRRangle
https://x.com/RRRangle/status/2122034454470574365
RRRangle writes up Kyle Mistele's AI Engineer World's Fair talk, and it is the clearest anti-pattern of the week: a 40,000-line PR, six review agents staring at it, zero humans able to read it. HumanLayer's fix is to treat the loop as a thermostat, not a while-true: one of roughly 150 old procedures per run, one run per day, the loop refuses to start if a PR is already open, and a deterministic sensor the agent cannot silence. The first version was switched off because correcting its output cost more than it saved. The rules worth stealing are the last three lines: every retry needs a reason, every attempt needs new evidence, and the budget lives outside the model.
πŸ’‘#2
@developermarker
https://x.com/developermarker/status/2121862266295554157
developermarker spent five days and about 4,000 dollars of tokens running autoresearch on the tactical engine of TactiCall, a football game you control by voice, cycling Claude Opus, Fable 5.2 and GPT Astra. Whole-team pressing went from 23 of 48 to 41 of 48, multi-step commands from 44 of 96 to 65 of 96. On a bigger run of 468 voice commands across Korean, English and Chinese with four seeds, 80.5 percent executed correctly and on time, but 97.3 percent eventually did the right thing. That gap is the finding: the agent usually knows what to do, the bottleneck is when, which is exactly the kind of metric a loop can climb once someone bothers to separate it out.
πŸ’‘#3
@igasemut
https://x.com/igasemut/status/2121569848153243802
igasemut summarizes a census of 36,487 repos that claim autonomous loops: only 217, or 0.59 percent, actually run one, 76 have a verifier, 55 have a stop rule and just 10 track cost. The punchline is that most agent loops are a cron job with your credit card attached. A trigger is not a harness, and if a loop has no verifier and no budget, what it automates is the token burn, not the work.
πŸ’‘#4
@OxEnsooo
https://x.com/OxEnsooo/status/2121994105894969497
OxEnsooo built a field report on the same census and boils it to one line: the model says done, the harness decides. The interesting part is the test design, four nights with a real Claude run, a cheater, a slacker and a check that cannot fail, all caught by a 90-line runner. It is a small, copyable answer to the 76-of-256 problem, where most loops never check their own output.
πŸ’‘#5
@javibuildz
https://x.com/javibuildz/status/2122005954652938335
javibuildz pulls the number every self-improving agent builder should tape to the monitor: with a keep-it-if-the-score-went-up gate, 45.59 percent of kept updates were worse than what they replaced, and a statistical gate cut that to 2.78 percent. The same trap applies to fine-tuning, where one higher eval run is noise, not progress. The question to ask of any loop is what bar an update has to clear before it ships.
πŸ’‘#6
@nyxienyxie
https://x.com/nyxienyxie/status/2122039893039730996
nyxienyxie reads the self-hosted Claude Managed Agents private beta that opened November 12 as a zero-retention story: you now run the server with the agent loop, sessions and history, Postgres to store them, and the workers that run bash and file tools in your sandboxes. The design details matter more than the headline. The server never connects to a worker, workers poll it; model turns keep running with no worker online and the first tool call just waits; with no database configured, sessions live in memory and a restart erases them. What does not move is that every model call carries the whole conversation, so self-hosting moves the transcript to your side and the job of securing it too.
πŸ’‘#7
@danshipper
https://x.com/danshipper/status/2122091033001337134
danshipper says Every has been chasing compounding skills, skills that get better each time you use them, and that a colleague finally cracked it. Over a weekend a skill for writing context-window summaries was iterated with autoresearch until it hit 80 percent of the author's own taste on summaries against a no-skill baseline. That is autoresearch pointed at taste rather than a benchmark, which only works because someone wrote down what good looks like first.
πŸ’‘#8
@satnam6502
https://x.com/satnam6502/status/2121914402899169683
satnam6502 previews a Cambridge talk whose closing example is a JSON scanner circuit derived by proved-correct transformations from its specification, inside an agentic loop that combines synthesis with formal verification. The output is correct by construction and comes with the AI's explanation of how it ties back to the spec, rather than being a black box. It is the strongest version of the verifier argument this week: when the check is a machine-checked proof, the loop cannot talk its way to done.
πŸ’‘#9
@kwinkich
https://x.com/kwinkich/status/2122027084432207928
kwinkich makes the same point from mathematics: the Lean formalization is what makes a multi-agent loop on a conjecture checkable. Humans set the reductions and the final structure, agents handled the bounds, the counterexamples and the extension to unbalanced cases. The split scales to other problems only as long as the output has to pass a machine-checked proof instead of stopping at a plausible write-up.
πŸ’‘#10
@sunny_b11
https://x.com/sunny_b11/status/2121598676028227790
sunny_b11 runs six agents in one terminal through the open-source Herdr multiplexer: one Claude Code as orchestrator that splits work into lanes, a second Claude Code on another account, Codex as a third builder, Devin on PR review, Grok on research. Agents drive Herdr through its API to hand work off and wait on each other, sessions survive closing the lid, and every agent writes what it did into a shared Obsidian brain repo. The rule that keeps it sane is one explicit lane per agent and no two agents touching the same thing. The sixth slot, Antigravity on Gemini, was pulled out twice; citing Theo's audit of Gemini 4 Carbon at 11-plus seconds to first token and caching that misses about 30 percent of the time, the author's point is that in a loop of dozens of steps, latency compounds.
πŸ’‘#11
@popcoornft
https://x.com/popcoornft/status/2121866366672097687
popcoornft reports a quiet ops win: a small multi-agent loop now closes the daily claim exceptions overnight. What used to be 40 minutes of manual matching every morning is now 7 minutes reviewing the flags it could not resolve. The line that matters is the last one, the real shift was trusting the routine path without hovering, which is the same thing HumanLayer had to learn from the other side.
πŸ’‘#12
@OwariDa
https://x.com/OwariDa/status/2122056172694114785
OwariDa answers the claim that Claude Code's harness is the secret sauce with Terminal-Bench 2.0 numbers. With Opus 4.6, Claude Code scores 58.0 percent, last of ten entries, while Terminus 2, whose only tool is sending keystrokes to tmux, gets 62.9; with Sonnet 4.5, the roughly 100-line mini-swe-agent beats Claude Code 42.5 to 40.1. Hold the harness fixed and swap the model, and Terminus 2 climbs from 38.0 to 62.9 across Opus versions. The argument is that the loop is cheap plumbing and the gains came from the network, which is worth weighing against this week's harness-is-everything threads.
πŸ’‘#13
@donaldgorbachev
https://x.com/donaldgorbachev/status/2121760377142657123
donaldgorbachev makes the quantization case in agent-loop terms: a 1.5 percent per-turn drift is invisible in a two-turn chat and fatal across a 50-step trajectory, since 0.985 to the 50th leaves 47 percent survival. The example card for a local MoE quant kept 36 linear-attention projection layers, routers and the multi-token head in FP8 or BF16 precisely because 4-bit wrecks state tracking. Static perplexity and single-turn trivia do not measure how agents fail, so anyone pricing a local loop should test it on long trajectories, not chat.
πŸ’‘#14
@kifsy18
https://x.com/kifsy18/status/2121590113797029922
kifsy18 offers the hot take that should save a lot of tokens: most people wiring autonomous agents to cron jobs just need a 100-line Python script and SQLite, or even a markdown file. Running a full stateful agent loop every three minutes just to see if new data exists burns ten times the tokens for nothing. Deterministic code first, the model only at the last mile.
πŸ’‘#15
@vaibhavbalkundi
https://x.com/vaibhavbalkundi/status/2122033403449286682
vaibhavbalkundi punctures the cheap-model euphoria: input is the cheap part, but the loop still pays 50 cents per million on output, plus every retry and tool call. Cheap input mostly lets a sloppy agent loop five times instead of thinking once. Cost per finished task, not price per input token, is the number that decides whether a loop is cheap.
πŸ’‘#16
@Masof_sol
https://x.com/Masof_sol/status/2122049958186725801
Masof_sol describes the simplest debugging upgrade in the feed: give every task a judge, tests and a type check, and make the agent loop until it is green. Then only read what is still red, not the whole diff. It is the verifier rule applied at the scale of one developer's afternoon.
πŸ’‘#17
@gubatron
https://x.com/gubatron/status/2121993254338257218
gubatron runs an agentic loop every hour that auto-fixes FrostWire and says waking up to its output is the best part. It is a one-line report, but an hourly fixer on a long-lived open-source app is exactly the small, bounded, deterministic-trigger loop the census says almost nobody actually ships.
πŸ’‘#18
@NHIDClinical
https://x.com/NHIDClinical/status/2121871364864844011
NHIDClinical reacts to Vapi's new Agent Loop, voice agents that test and ship their own fixes toward a goal like resolution rate, with a rule optimizers forget: whatever the loop tunes, disclosure should not be a knob. In their clinical setup, the identity disclosure check is a pass or fail on every turn, not a score to trade off. Self-improving loops need some constraints that sit outside the objective entirely.
πŸ’‘#19
@genneelcool
https://x.com/genneelcool/status/2122025523819770315
genneelcool reduces Karpathy's autoresearch to the rule that keeps it honest: the agent edits one file, and the metric lives in another file it is not allowed to touch. No moving the goalposts. Most failed copies of the loop break exactly here, by letting the agent near the scorer.
πŸ’‘#20
@venkatGoku
https://x.com/venkatGoku/status/2121825158860288481
venkatGoku, running both Karpathy's autoresearch and Codex as autoresearchers on GPT Astra, says there is no juice left: these systems stay stuck inside the frame of thought they were given. It is like using a smarter brain to follow your dumb directions rather than question the direction itself. The next experiment is a different setup that can challenge the brief, which is the exploration problem stated by a practitioner rather than a paper.
πŸ’‘#21
@franklyteddy
https://x.com/franklyteddy/status/2121865204854383052
franklyteddy suggests a concrete fix for greedy loops getting stuck: make the architecture the unit of search, put a taxonomy over architecture families, and greedily autoresearch inside one family at a time. Mixing explore across families with exploit within them means the greedy search never has to climb out of a local minimum on its own.
πŸ’‘#22
@fcesco
https://x.com/fcesco/status/2122077289944867277
fcesco reached rank 8 on the okc leaderboard by doing autoresearch with branch-and-cut style methods and calls the approach ultraresearch. Borrowing branch and cut from integer programming is one of the few concrete answers this week to how a loop should prune and backtrack instead of just keeping the last best score.
πŸ’‘#23
@ReduxAbsurdum
https://x.com/ReduxAbsurdum/status/2121845316177846645
ReduxAbsurdum reports from quant trading that 5.5 is making significant progress on auto research, and does much better in areas where the firm's own common knowledge is thin. Trading has some verifiability built in, which is why it keeps showing up as the domain where these loops pay first.
πŸ’‘#24
@nisalrenuja
https://x.com/nisalrenuja/status/2122052264047394988
nisalrenuja finds that tuned BM25 plus a strong agent loop can match dense retrieval on deep-research benchmarks, so you may not need an embedding model for tool search. Pair the same retriever with a weak model and it falls apart. The retriever is only as good as the brain calling it, which says the loop, not the index, is carrying the result.
πŸ’‘#25
@Shadyshandilya
https://x.com/Shadyshandilya/status/2121933432125268164
Shadyshandilya ended up building agent-to-agent message passing anyway and argues the agentic loop should separate a control plane from a data plane, so routing and checks happen before the expensive model call goes out. Unix sockets worked but felt wrong. It is the same instinct as the durable-execution crowd: keep orchestration cheap and deterministic, spend the model only where judgment is needed.
πŸ’‘#26
@getdarshan
https://x.com/getdarshan/status/2121770533406769599
getdarshan sets a bar for calling anything recursive self-improvement: when models can define, quantify and optimize on diversity as a metric. Until then, the tapering curves coming out of almost every autoresearch and harness lab are the best anyone has. It is a one-line restatement of the exploration problem, and a useful test for the next RSI claim.
πŸ’‘#27
@apurvag16
https://x.com/apurvag16/status/2121982829899002136
apurvag16 argues the long pole for auto-research is real-world tasks with real users, which are hard to simulate, and that false precision accumulates when a loop never touches reality. The proposal is to close the loop around the economy rather than inside individual labs, so the feedback comes from the world instead of a sterile benchmark.
πŸ“‘ Eco Products Radar
Eco Products Radar
Karpathy's autoresearch: still the reference loop, from TactiCall's tactical engine and the Every writing skill to the keep-or-revert explainers and the endless repo-list threads.
Claude Code: the default harness inside most of these loops, and the subject of the week's harness-versus-model argument.
Claude Managed Agents (self-hosted): the private beta that moves the agent loop, sessions and sandboxes into your own cloud, read closely for what still leaves the network.
Fable 5.2: the model people point their loops and agent teams at this week.
Gemini 4 Carbon: the cautionary tale, cited for first-token latency and cache misses that compound across agent steps.
← Previous
Super User Daily: 2026-11-16
Next β†’
Ideas Radar: 2026-11-16
← Back to all articles

Comments

Loading...
>_