November 17, 2026loop

Loop Daily: 2026-11-17

The cheapest loop win of the weekend was a bug fix, not a smarter model. One code-search team stopped trimming old tool results, the prompt cache started hitting again, and average turns per answer halved. The same lesson kept showing up from different angles: Terminal-Bench numbers where one model swings seven points depending on the harness, a reading list of self-improving agent papers that mostly catch agents getting better at the benchmark instead of the task, and a speedrun benchmark where an agent only gets one score per attempt and still learns to clear a level. Research loops got a new sort of scoreboard too, with a twenty-questions test for how an LLM searches its way to an idea and a sponsor offering to fund open auto-research races after the integer multiplication repo. Away from code, one person is wiring sleep sensors, DuckDB and Claude Code into a loop judged by a three-button pad. The loudest posts were still copy-paste threads stacking Dario, Schmidt and Alexandr Wang clips on top of Karpathy repo lists, plus one-prompt agent cards and the AdaL reply farm; none made the cut.
πŸ’‘#1
@clarveloai
https://x.com/clarveloai/status/2122314133034897912
clarveloai found that their code-search agent was paying for its own tidiness. On every turn the harness shortened older tool results to save space, which changed the start of each request, so the provider's prompt cache could never reuse it, and the model also lost results it had already seen and searched for them again. The fix was boring: each request now just appends to the previous one. Average turns fell from 5.2 to 2.6 and the worst case went from 40 turns to 5. If your loop edits its own history, check your cache hit rate before you blame the model.
πŸ’‘#2
@stretchcloud
https://x.com/stretchcloud/status/2122174822046187639
stretchcloud lines up the Terminal-Bench 4.0 numbers that keep embarrassing model rankings: the same Opus 5.5 at max effort scored 64.85% at $14.30 a task inside Claude Code's full toolbox, and 71.2% at $12.19 inside Unharnessed, which is basically one persistent Python REPL. The public board shows that model anywhere from 61.8% to 70.6% depending on whose harness runs it. The response was to build Campfire, which runs Claude Code, Codex, Goose, Aider, OpenHands and others on the same task and model in isolated git worktrees side by side, with a cost dashboard. Fewer tools, higher score, lower bill: the loop is a set of decisions, and you should test those decisions on your own repo.
πŸ’‘#3
@TheTuringPost
https://x.com/TheTuringPost/status/2122333725786620408
TheTuringPost sorted a week of self-improving agent papers by the question that matters: is the agent learning the task or learning the verifier? One paper shows an embodied coding agent's score rises when it sees the success criteria while actual task completion does not; another finds harness evolution lifts benchmarks with no weight updates but the gains are unreliable, expensive and transfer poorly. The constructive ones separate writing a change from shipping it, requiring fresh paired audits and a non-inferiority check before any self-generated update lands, and Harness^2 keeps only edits that help on new tasks without an answer key. The closing question is the right one for anyone running these loops: who decides which edits stay.
πŸ’‘#4
@VarunGangal
https://x.com/VarunGangal/status/2122176290757476441
VarunGangal and co-authors ran Thinking Machines' Inkling-2-Small through SpeedRunBench, where an agent plays a SuperTux level over and over and only gets a single score after each attempt to refine its policy offline. Inkling-2-Small cleared level 1-1 in 1,988 frames, second among open models only to GLM 5.3 at 1,961, and ahead of Gemini 3.7 Flash, GPT-5.6-sol, Claude Opus 5 and DeepSeek-V4-Flash; its predecessor never cleared the level at all. The human world record is 1,619 frames, so there is still a gap. The design is the interesting part: no mid-episode updates and no frame understanding, which makes it a test of planning and exploration under a sparse score, the same shape as an autoresearch run.
πŸ’‘#5
@muhan_gao
https://x.com/muhan_gao/status/2122437641576595577
muhan_gao introduces Re-Search, which turns LLM ideation into a game of Twenty Questions: the model asks yes or no questions to rediscover the core idea of a published paper. The point is that we only ever see the end product of AI research claims, from Erdos problems to a claimed Navier-Stokes proof, never the search that got there. Making each ideation step observable means you can measure where an autoresearch loop gets stuck instead of guessing from the final paper. For anyone building research loops, this is a scoreboard for the part that usually goes unlogged.
πŸ’‘#6
@RohanArun
https://x.com/RohanArun/status/2122352241004728823
RohanArun wants to turn the recent integer multiplication repo, where auto-research agents kept pushing the record, into an open competition format with real prize money, and offers to fund the rewards and bring in more sponsors. The inspiration is an algorithms professor who built a backend for each class so students' solutions fought each other. Proposed targets are concrete: specific matrix multiplication sizes that would speed up systems everywhere, a race to formally verify critical infrastructure like SQLite or TLS, and faster SAT and SMT solvers, which in turn speed up verification. Auto-research needs well-defined scoreboards, and prize money is a quick way to get people to build them.
πŸ’‘#7
@mmatthias
https://x.com/mmatthias/status/2122356501251498291
mmatthias sketches a loop well outside code: store every sleep sensor reading in Parquet, analyze it with DuckDB, expose it to Claude Code through an MCP server so an autoresearch loop can experiment on the sleep setup, and use a pad with three buttons to rate each night as great, fine or bad. The three-button pad is the clever bit, because it gives the loop a human metric that costs two seconds every morning. The admitted plan is lots of work up front, then hoping the loop takes over most of it. Any personal habit with a cheap daily rating can be turned into this kind of loop.
πŸ’‘#8
@michielmv
https://x.com/michielmv/status/2122433779436523976
michielmv brought Claude Managed Agents to boxd using Anthropic's self-hosted environment, still in beta, where Anthropic hosts the model and the agent loop but every bash, read, write, edit, glob and grep call runs on your machine. Each session gets its own machine with its own kernel, root and disk; a worker long-polls Anthropic's work queue over outbound HTTPS so no ports are open; between turns the machine goes to standby and resumes in under a millisecond with files and processes exactly as the last turn left them. That split, a hosted brain with tools running on a box you control, is becoming the default answer to the question of where an agent loop should run.
πŸ’‘#9
@Haoquan03
https://x.com/Haoquan03/status/2122365279720382711
Haoquan03, looking at AI-written reviews in the current conference cycle, argues that taste is the real bottleneck for auto research: models are closing the execution gap, but they still cannot tell a good idea from a merely plausible one. Human papers and peer reviews look like the natural training signal for taste, yet the more people use AI to generate ideas, papers and reviews, the less clean human data there is. The worry is a taste deadlock where frontier models stop getting better at judging research because the judgment data has been diluted. It is a sharp counterweight to the idea that more loop iterations alone will produce better science.
πŸ’‘#10
@rdominguezibar
https://x.com/rdominguezibar/status/2122374422174838813
rdominguezibar quotes Alexandr Wang at Startup School 2026 telling Garry Tan that inside Meta, with the right agentic loop and an evaluation system with a metric to optimize, a swarm of agents out-produces a team of 100 engineers very easily. Stripped of the hype, the claim has two load-bearing parts, the loop and the metric, and the second one is the hard one. Agents will chase whatever number you hand them, so for founders the scarce skill becomes writing a metric that cannot be gamed. The same clip was recycled all weekend in copy-paste threads; this is the version that actually says what it implies.
πŸ’‘#11
@spencer_clark
https://x.com/spencer_clark/status/2122276099405103539
spencer_clark builds an eval harness for an agent that actually does things, starting from the point most agent evals skip: checking the final reply is not enough. The harness verifies the resulting state, the tool calls the agent made along the way, and whether it followed the rules while doing it. That is three separate checks for what most people grade as one answer. For any loop that writes to real systems, the state check is the one that catches the confident wrong answer.
πŸ’‘#12
@Rafa_Schwinger
https://x.com/Rafa_Schwinger/status/2122165922576338950
Rafa_Schwinger offers a practical trick for tools a model was not trained on well: set up a verifiable autoresearch environment and let it run for a day, and it will work out a few hacks on its own. The same author also suggested Z.ai build exactly that kind of loop to catch the zcode harness bug where memory grows until it runs out. The shared idea is that a loop with a checkable outcome is a cheap way to learn an unfamiliar tool or to hunt down a misbehaving harness. A day of compute replaces a week of reading docs.
πŸ’‘#13
@framebufferobj_
https://x.com/framebufferobj_/status/2122265971859898683
framebufferobj_ stripped Antigravity's hooks and features down to a raw agentic loop and noticed a change in behavior: the agent first reads every file it needs, then edits a whole batch of them at once, as if it were planning and executing in the same pass. With fewer tools and less scaffolding in the way, the model falls back on a read-everything-then-act pattern. It is one person's observation, but it lines up with this week's Terminal-Bench result where a stripped harness beat the full one. Sometimes the fastest loop is the one with the least furniture.
πŸ’‘#14
@plainsupport
https://x.com/plainsupport/status/2122440245170061604
plainsupport shipped Customer Agent v3.3, which now runs as an agentic loop and is about 50% faster, down to roughly six seconds per answer. The design choice worth copying is what stays fixed: security rules and AI disclosure are locked, and the customer's own instructions control everything else. That is the same principle a clinical voice team argued for a few days ago, where disclosure is a pass or fail check rather than something the loop can tune. Customer-facing loops are settling on a small set of non-negotiables plus everything else configurable.
πŸ’‘#15
@SystemArch_AI
https://x.com/SystemArch_AI/status/2122434535237283964
SystemArch_AI points at the least glamorous agent launch of the week, Cloudflare's opt-in spending caps for Workers and Durable Objects. For agencies running client workloads on serverless, one runaway agent loop used to mean an ugly invoice and an awkward client call; now the cap stops it before it happens. The budget lives outside the model, which is exactly where it should live. Boring cost controls are what make it possible to sell autonomous loops to clients at all.
πŸ’‘#16
@rakyll
https://x.com/rakyll/status/2122192768344973660
rakyll, working on agent infrastructure at Google, describes the agentic loop as looking more and more like a job controller loop: the hard part is provisioning and starting jobs fast enough, which turns agents into a scheduling problem. The post doubles as a hiring pitch for people who want to solve exactly that. It is a useful reframe, because once each turn spins up sandboxes and tools, latency and placement decide how many iterations you get per hour. The loop people talk about is the model; the loop that ships is the scheduler.
πŸ’‘#17
@developermarker
https://x.com/developermarker/status/2122214434131317061
developermarker is building Tacticall, a football game where the manager speaks plain English and the team responds, with autoresearch tuning the execution engine behind it. The loop is not writing the game's features; it is adjusting how voice commands turn into on-pitch behavior, a target that is easy to score and tedious to tune by hand. It is a good example of where autoresearch fits outside ML: anywhere there is a large parameter space and a quick way to tell whether a match played out better.
πŸ’‘#18
@RituWithAI
https://x.com/RituWithAI/status/2122228035432886777
RituWithAI walks through COG-second-brain by Huy Tieu, an open-source framework that turns local Markdown files into an agent workspace across Claude Code, Cursor, Antigravity, Kiro and Gemini CLI, with 43 skills and 10 worker agents. The part relevant to loops is the verification harness: the worker never grades its own homework, and separate read-only verifiers check artifacts against falsifiable acceptance criteria. It also routes cheap collection to Sonnet and reasoning to Opus, and includes an /auto-research workflow for product research. The pattern of splitting doer and checker is turning into a default for personal agent setups.
πŸ“‘ Eco Products Radar
Eco Products Radar

Karpathy's autoresearch: the reference design everyone explains, one editable file, a fixed five-minute run and a keep-or-revert rule; also the most copy-pasted link of the weekend.
Claude Code: the default host for personal loops, from sleep experiments over MCP to Markdown second brains, and one of the harnesses on the Terminal-Bench comparison.
MCP: the glue that lets loops reach sensors, databases and tools.
← Previous
Super User Daily: 2026-11-17
Next β†’
Ideas Radar: 2026-11-17
← Back to all articles

Comments

Loading...
>_