November 23, 2026loop

Loop Daily: 2026-11-23

The loop got turned on the instructions this window, not the code. One builder let an agent loop rewrite a production system prompt from zero and it threw away 75% of it, got better output and ran 25% cheaper. LangChain's harness work kept getting quoted for the same reason: 52.8% to 66.5% on Terminal-Bench 2.0 with the model untouched, mostly from a check before the agent declares itself done and a detector for editing the same file in circles. Google's GUARD paper pushed the idea further by freezing weights and letting the agent edit only its tool rules and procedural memory. Meta showed loops building the evals too: Benchmark Factory turns merged code changes into benchmarks and repairs them until bad ones get caught 98.6% of the time. The cost side got blunter. A runaway loop reportedly burned $47,000 in 11 days behind green monitoring, and the advice that kept coming back was to plan with the expensive model and run the loop on the cheap one. Karpathy lecture clips, Hermes Agent promos and AdaL reply farms stayed loud and are not here.
πŸ’‘#1
@jachands
https://x.com/jachands/status/2123612005890232652
@jachands ran an agent loop this week that deleted the entire system prompt of the agentic product the team is building and worked out from scratch what the agent actually needed. It cut 75% of the prompt, the output got better, and runs got 25% faster and cheaper. The lesson the author draws is that years of patches against bad behavior were the problem: tell the model its environment, its goal and its purpose, give it a way to test itself, and it can run for hours or days. The rest of the post is a field list of where agents still trip on Cloudflare, from Access rules to a defensive 10-second retry on Durable Objects that respawn almost instantly.
πŸ’‘#2
@MaryamMiradi
https://x.com/MaryamMiradi/status/2123875734305345575
@MaryamMiradi went through LangChain's harness research, where a coding agent climbed from 52.8% to 66.5% on Terminal-Bench 2.0, from outside the top 30 into the top 5, without changing the model. The two fixes singled out are concrete: a check before completion that makes the agent verify its work against the original task, and loop detection that catches an agent editing the same file over and over without progress. The post maps the stack into five layers, from the agent loop and tool engineering to memory files and evaluation. The closing rule is useful: if you already know the steps, a workflow is enough, and you only need an agent loop when the next step depends on what the agent finds.
πŸ’‘#3
@TechThought_org
https://x.com/TechThought_org/status/2123770900931641605
@TechThought_org summarized GUARD, a Google paper on catastrophic forgetting in recursive agent harnesses. Instead of touching weights, GUARD freezes the base model and lets the agent selectively edit its tool rules and procedural memory, with systematic self-checks guarding what gets written. Reported results are 80.80% accuracy across SDK benchmarks, memory pollution eliminated, and token use down 54.5%. It is the cleanest version yet of the idea that a self-improving agent should improve the files around the model, with a gate on every write.
πŸ’‘#4
@buckleyplanet
https://x.com/buckleyplanet/status/2123612627783839811
@buckleyplanet passed on Anthropic's own advice to enterprise teams: fold the routers, planners and specialist subagents back into one agent loop with skills. In Anthropic's comparisons that single loop often won on quality, cost and latency. The line that sticks is that most multi-agent diagrams are org charts dressed up as software. It is a direct counterweight to the swarm diagrams that fill the same timeline.
πŸ’‘#5
@WrongNebula
https://x.com/WrongNebula/status/2123694634899804196
@WrongNebula showed a co-evolution loop for 3D modeling: start from a low-poly house, project textures with Potemkin3D, detect depth and normals, feed that back into a custom harness, and repeat until the detail level is good enough. The author calls it Karpathy autoresearch for modeling. The metric here is visual rather than a single number, which is exactly the kind of domain where people said the recipe would not travel.
πŸ’‘#6
@nittinpatil
https://x.com/nittinpatil/status/2123687642906919080
@nittinpatil flagged SimScale and Nominal putting simulated design and physical test into one agentic loop, announced around Formnext 2026. Simulation proposes and FEA and CFD runs check, then test data from Nominal feeds the next design round. This is autoresearch moving into engineering hardware, where the expensive part of the loop is a test rig rather than a GPU.
πŸ’‘#7
@KrisRifenburg
https://x.com/KrisRifenburg/status/2123844452489838696
@KrisRifenburg opened with a number: a runaway agent loop reportedly cost a team $47,000 over 11 days while monitoring stayed green, and the first alert fired after the money was gone. The pitch is for Nerve, which gives every agent a spend ceiling, pauses the work when it is hit and pages a human, at the level of one agent or the whole fleet, with every dollar traced to an agent and task. The framing is the useful part: an alert tells you what happened, a ceiling decides what is allowed to happen.
πŸ’‘#8
@jjjhenriksen
https://x.com/jjjhenriksen/status/2123851605409964368
@jjjhenriksen is working on @RohanArun's auto-research verification of the machine-checked Riemann Hypothesis proof that dominated the week. The post is short and excited, but it marks where autoresearch went next: from producing a result to verifying one, with several people collaborating on the checking loop. Context from elsewhere in the window puts the proof at roughly 250,000 pages with a lot of Lean, which is far past what humans can read, so verification has to be a loop too.
πŸ’‘#9
@bibryam
https://x.com/bibryam/status/2123836751647277401
@bibryam put the durable-agent problem in one line: a durable agent is a durable execution or workflow engine, which is the hard part, integrated with the agentic loop, which is the easy part. That inverts how most agent frameworks are marketed. The loop is a few dozen lines, while surviving crashes, resuming state and not repeating side effects is where the engineering goes.
πŸ’‘#10
@jose_medina
https://x.com/jose_medina/status/2123855275296006566
@jose_medina answered the argument that you should always pay for the smartest model. That math holds for hard jobs, but inside an agent loop most steps are reading a tool result and choosing the next call, and a frontier model there is Einstein filing invoices. The recommendation is to plan with the expensive model and run the loop on the cheap one. It is the same split showing up in routing setups all month, said in a way that is easy to remember.
πŸ’‘#11
@livetab_
https://x.com/livetab_/status/2123849005339664863
@livetab_ gave a concrete migration order for agents on OpenAI: Chat Completions is now the legacy path, since GPT-6 Astra and GPT-6.2 Astra and Sol still run there but tool calling on them requires the Responses API. Move the agent loop first as its own change, then swap the model. Separating the two changes means that when something breaks, you know whether it was the loop or the model.
πŸ’‘#12
@AdamGavish
https://x.com/AdamGavish/status/2123733345238393232
@AdamGavish argued that the first decision in AI coding infrastructure is architecture, not the model, and laid out three options: one agent that holds all context and makes every decision, a team of agents each with its own persistent context, or one agentic loop that spins up subagents on demand. Later in the thread the third option is matched to evolving projects with a clear objective but unclear subtasks, where the main agent keeps the lessons learned and subagents are disposable. It lines up with Anthropic's own fold-it-back advice from the same day.
πŸ’‘#13
@pauliusztin_
https://x.com/pauliusztin_/status/2123770840353263842
@pauliusztin_ built Decode, a coding agent in Python modeled on how Claude Code, Codex, OpenCode and Aider work, and turned the build into a free open-source course of 8 articles and 6 videos. The syllabus covers the ReAct agent loop, sandboxing, memory and compaction, subagents, cloud runs from cron and webhooks, evals, and record and replay for reproducing failed runs. A reply asked the right follow-up: the loop is the weekend part, so what took longest, compaction or deciding when the agent should stop and ask.
πŸ’‘#14
@SciFi
https://x.com/SciFi/status/2123595658091229560
@SciFi surfaced the arXiv paper Harnesses That Improve Themselves by Deep Shah and Nehal Kathrotia, which proposes a unifying framework for self-improving agent harnesses. The timing matters: in one window GUARD, LangChain's harness results and Anthropic's single-loop advice all argue that the harness, not the weights, is where improvement lives. A framework paper is the sign that the idea is moving from tricks to a field.
πŸ’‘#15
@arnaudmercier
https://x.com/arnaudmercier/status/2123663954484310245
@arnaudmercier shared ResearchFlow-Eval, a paper tracing the execution gap in end-to-end multi-claim autoresearch. The target is the gap between an agent that can state a plausible research plan and one that actually executes every claim in it. That is the failure mode most autoresearch demos hide, and a benchmark built around it is worth watching next to the newer cost-per-task indexes.
πŸ’‘#16
@Pro_Algorithm
https://x.com/Pro_Algorithm/status/2123636689025327512
@Pro_Algorithm reported that Brain, the personalization agent inside Perplexity Computer, now writes self-improving skills automatically. It learns how the user works from past sessions and memory, writes personalized skills for future tasks and keeps rewriting them over time. This is the skills-as-memory loop shipping inside a consumer product rather than a developer harness, and the open question the post asks is whether people want an agent writing its own playbook for their job.
πŸ’‘#17
@dr_hb_ai
https://x.com/dr_hb_ai/status/2123750306878046618
@dr_hb_ai pointed at autoresearch for biology through short RNAs. With short RNAs you can often skip growing cells, so the design, make and test cycle can run faster than for many proteins. Loop speed decides how many iterations a lab gets, and that makes RNA a natural first target for autonomous wet-lab research.
πŸ’‘#18
@yim0e
https://x.com/yim0e/status/2123581856918683765
@yim0e looked through what the autoresearch models produced on what reads as a basketball analytics task and was struck by one of them, while staying unsure whether its methodology holds up even though it scored well. The aside that RAPM, the standard plus-minus adjustment, isn't needed is the kind of claim a loop surfaces and a human then has to check. Sports analytics is one more non-coding domain where people are reading machine-generated models rather than writing them.
πŸ’‘#19
@linuxbox
https://x.com/linuxbox/status/2123822671909507411
@linuxbox credited the chain behind pi-autoresearch: @davebcn87 built it and @tobi turned it into something anyone can run, on top of @badlogicgames' Pi coding agent. It is a reminder that the version of autoresearch most people actually run is a fork of a fork, and that packaging work is what took it from a lab script to a tool.
πŸ’‘#20
@yacinelearning
https://x.com/yacinelearning/status/2123822771696275458
@yacinelearning made an observation about current auto-research methods: they are extreme brute forcing, chaining ideas into territory where a human would have abandoned the trail a thousand times over. That is both the strength and the cost. A loop has no sense of embarrassment about a dead end, so it keeps going where people stop, and it pays for every one of those steps in compute.
πŸ’‘#21
@awelonblue
https://x.com/awelonblue/status/2123850131459994093
@awelonblue argued that autonomy, not agency, is the real question for claims that AI invented something: if a human walked it through every step, it did not. The proposed test is to give an agentic loop a $1M budget, a general goal and the tools to experiment, iterate and get feedback. It is a clean way to frame what an autoresearch result would need to show before anyone calls it discovery.
πŸ’‘#22
@merklefruit
https://x.com/merklefruit/status/2123887003439661398
@merklefruit described a habit worth copying: keeping a deliberate line between shipping features and improving the agent loop's speed or quality inside each project. The author calls the second kind of work swarm-ops, in the same spirit as getting a repo swarm-ready. Treating the loop as its own backlog item is how teams stop the harness from rotting while everyone ships features through it.
πŸ“‘ Eco Products Radar
Eco Products Radar

Karpathy's autoresearch: still the reference recipe, cited for 3D modeling loops, the pi-autoresearch fork chain and a steady stream of lecture-clip promos that were left out.
Claude Code: the architecture most harness explainers describe, and one of the agents Decode was modeled on.
Codex: the other half of every harness comparison, and an agent Decode was modeled on.
LangChain: the 52.8% to 66.5% Terminal-Bench harness result quoted across several posts.
Hermes Agent: Nous Research's self-improving agent, pushed by promo posts and a Grok reply, left out of the cases.
NanoChat: the training codebase autoresearch series keep tuning against, those posts handed to AI for AI.
← Previous
Super User Daily: 2026-11-23
Next β†’
Ideas Radar: 2026-11-23
← Back to all articles

Comments

Loading...
>_