November 19, 2026loop

Loop Daily: 2026-11-19

Math is where autoresearch got real this week. One mathematician ran a new frontier model in research campaigns that grind for one to four hours on a single "carry on", another person woke up to a new upper bound in Terence Tao's optimization constants table found overnight by a Claude loop, and two separate harnesses now push math results all the way into Lean proofs. Lean keeps showing up for the same reason: when the agent produces the ideas, something outside the agent has to check them. That was the second thread. A Google paper on self-rewriting harnesses found that gated, one-module-at-a-time edits get nearly the full gain at a tenth of the tokens, a statistical gate cut bad accepted updates from 45.59% to 2.78%, and an RSI cost study says verification is the biggest bill in the whole loop. Anthropic's advice to fold subagent org charts back into one loop spread fast, and OpenAI told API builders to stop editing earlier context mid-loop. The honest note of the week came from a trading-bot loop that improved fast for 20 rounds and then stalled. The loudest posts were clip threads stacking Schmidt, Karpathy, Ilya, Dario and Musk quotes on top of repo lists, GTA 6 money playbooks and a reply farm selling a GTM agent; none made the cut.
πŸ’‘#1
@nasqret
https://x.com/nasqret/status/2122805624350064832
nasqret spent two weeks as an early tester of GPT-6.2 Astra and wrote up what it is like as a working mathematician. The workflow is agentic CLI mode with every command visible and no YOLO mode: set up the task with a self-built "labyrinth" skill, watch the first runs, then say "carry on" and let it hunt for one to four hours per cycle. Out of that came a classification of semigroups of order 7 (almost a million objects), a rewrite of Mizar into a modern kernel, a breakthrough on elliptic divisibility sequences and a few million lines of structured Lean in two weeks. The key line is that with AI-generated math, Lean is a necessity, not a nice-to-have. In follow-ups the author said the first one to two hours are spent babysitting and steering, and only then does the model get the overnight campaign.
πŸ’‘#2
@CharlesWeill
https://x.com/CharlesWeill/status/2122792517381099958
CharlesWeill built an autoresearch loop with Claude to work on math and woke up to a new result: an upper bound of 1.4513064 on the signed third autocorrelation constant in Terence Tao's optimization constants table, beating the previous best of 1.4540711. No team, no lab, one loop running overnight against a public leaderboard of hard constants. This is the purest version of the Karpathy recipe: an editable candidate, a number that can be checked by anyone, and a night of compute. Tao's table is turning into a de facto benchmark for these loops, and the improvements are small but real.
πŸ’‘#3
@WShuiyin
https://x.com/WShuiyin/status/2122945791430176789
WShuiyin released MathRSI, a self-improving harness for math discovery and proof. It pairs a shared base loop with domain plugins and a workspace memory, and the important part is what goes back into the harness: reductions, counterexamples and dead ends are distilled into the harness itself, versioned from v0 to v6. The team claims results on six classical problems, including closing 40-year-old gaps, settling open cases, tightening bounds and proving Lean 4 theorems. It ships as slash commands for research and for verify-and-repair of a proof. The design bet is that the dead ends are as valuable to keep as the wins.
πŸ’‘#4
@arxivupdates
https://x.com/arxivupdates/status/2122934350027137087
arxivupdates flagged Colombo, an autoresearch system for mathematical optimization. It uses self-organizing agents, formal certification in Lean and an adversarial co-ascent setup to discover and prove optimal complexity bounds across more than 50 settings. Adversarial co-ascent means one side pushes the bound while the other tries to break it, so the loop has a built-in critic instead of trusting its own output. Together with MathRSI and the Astra field report, it is the third math loop this week where the proof assistant, not the model, has the last word.
πŸ’‘#5
@omarsar0
https://x.com/omarsar0/status/2123077276350976396
omarsar0 summarized a Google paper that let an optimizer rewrite the harness around a frozen Gemini 3.8 Flash on SWE-bench Lite. A prompt rule file actually lowered held-out accuracy from 5.0% to 2.5%. A full harness rewrite reached 42.5% at 451.6k tokens per task, while gated edits to one module at a time (context, control, tools or verification), each checked on held-out tasks under a token cap, reached 40.0% at 46.7k tokens. The gated harness also transferred to Gemini 4 Argon with no new search, 37.5% against 30.0% for the full rewrite. The test set is only 40 issues, but the shape is clear: small gated edits keep almost all the gain for a tenth of the cost and generalize better.
πŸ’‘#6
@bymichaelliang
https://x.com/bymichaelliang/status/2122887133576790400
bymichaelliang made the sharpest case of the week that a self-improving agent is often just overfitting with extra steps. The usual rule, keep the change if the validation score goes up, reuses a small validation set, so noise looks like progress; in the cited work that naive gate kept worse updates 45.59% of the time, while a statistical gate did it 2.78% of the time. The recipe: the proposer never sees the gate's eval set, require evidence beyond noise, gate on no-regression across slices, budget false accepts across the whole loop and keep one-click rollback. The last rule is the one people skip: a human owns the gate code, and the agent can rewrite its prompts, memory and tools but never its own judge.
πŸ’‘#7
@RobertTLange
https://x.com/RobertTLange/status/2122936854722818146
RobertTLange pointed to an "RSI tax" paper that does something rare: it counts the tokens. Running autoresearch for pre-training at a trillion-parameter scale is simply unaffordable, and cheap proxy tasks that generalize are hard to find. The paper's findings are that performance gains alone give a misleading picture of what recursive self-improvement adds, that verification is the dominant measured expense, that a simple bounded-note baseline is competitive, and that a lot of adaptation spending produces artifacts never used later. The proposal is to plot discovery harnesses against token cost on the x-axis, the same way LLM benchmarks moved to token efficiency.
πŸ’‘#8
@alexlavaee
https://x.com/alexlavaee/status/2122558849643401241
alexlavaee answered the popular "build the verifier first and let the agent loop" advice with the case where it breaks: when the agent writes the verifier. Every test passes and the change still has gaps, because the same agent wrote both code and tests, and an agent with edit access to a formal spec can weaken an invariant until the checker says zero errors. The rules: a separate verifier agent or tool, read-only tests and specs pinned by hash so the run fails if they change, deliberately reinserting an already-fixed bug to see if the verifier catches it, and spending most of the time on whether the check matches the intent. It cites DeepMind's AlphaProof Code work on Signal, where humans approved the spec and the provers could not touch it.
πŸ’‘#9
@DanKornas
https://x.com/DanKornas/status/2122637360777064591
DanKornas highlighted Thermite, an open-source autoresearch tool built around one rule: agents propose changes, a separate judge builds, tests and measures them against the best version so far, and agents cannot read or modify the judge. Improvements have to hold up on repeat runs. It runs three campaign modes (optimize a metric, meet a checklist, or research a question with source-checked quotes), runs parallel experiments in separate code copies pulling from a shared idea queue, and keeps losing attempts with their code and verdicts. It is Apache 2.0 and the README warns parts will break, but it is the gate-first design the rest of the week was arguing for, already packaged.
πŸ’‘#10
@etuleu
https://x.com/etuleu/status/2122511827016004087
etuleu set up an autoresearch loop with Grok bot to iterate on a trading bot. It improved quickly over about 20 rounds and then got stuck, and the author has seen the same plateau in other domains. It is a small post, but it is the most common real outcome of these loops and the one nobody puts in a thread: fast early gains on the obvious knobs, then a flat line. The fixes people suggest in this week's other posts are the same ones: a fresh exploration strategy, a cleaner gate so noise stops counting as progress, and a human who knows the domain.
πŸ’‘#11
@every
https://x.com/every/status/2123145097521066158
every's weekly roundup carried one real autoresearch build: hammer_mt made map-driven autoresearch, where the agent reads a map of 104 methods and decides which experiments to run next, instead of guessing from scratch each round. The explainer video was also made entirely in code. A method map is a cheap answer to the plateau problem: the loop stops re-trying the same three ideas because it can see which regions of the space it has not touched. The same roundup noted the team published a vibe check of GPT-6.2 Astra and Sol, the models several loop builders were testing this week.
πŸ’‘#12
@shikhargupta02
https://x.com/shikhargupta02/status/2122513403113836588
shikhargupta02 reacted to a paper that systematically evaluates how agents explore different directions, called basins, and admitted this is the daily struggle: how to steer an autoresearch agent between depth and breadth on one problem. The honest conclusion is that you still need to be a subject-matter expert to give the agent directions and stop it from overfitting to the first basin it finds. It lines up with the trading-bot plateau and the method-map idea in the same window: exploration, not raw model strength, is where these loops are stuck.
πŸ’‘#13
@DianboLiu
https://x.com/DianboLiu/status/2122914298448187527
DianboLiu posted a preprint with a specific claim about research loops: machine learning model designs usually contain components that conflict with each other, and guiding the autoresearch system to resolve those conflicts produces long-term gains in the loop. That is a different instruction from the usual "make the score go up". The agent is told to look for tension inside the design, which gives it a reason to restructure rather than keep tuning hyperparameters, the failure mode loop builders keep complaining about.
πŸ’‘#14
@lxe
https://x.com/lxe/status/2122931582923395242
lxe described running an autoresearch lab on Orble: set up the workspace once with its running programs and network connections, then clone it into any number of workers, always from a lineage that passed grading. A supervisor agent drives the Orble CLI or MCP to fork, pass notes, steer and orchestrate. Forks take milliseconds instead of worktree setup, each fork starts as clean as its parent or the root, so the workspace does not bloat over rounds, and isolation is enforced so memories do not leak between branches. It is the infrastructure half of the exploration problem: branching cheaply from known-good states.
πŸ’‘#15
@TamirSPIRITT
https://x.com/TamirSPIRITT/status/2123155152735793572
TamirSPIRITT applied Karpathy's autoresearch to business problems and says you can hill-climb almost any business metric that has a feedback loop of weeks, not minutes. The example is AEO and SEO visibility, shown climbing steadily, and the loop is now built into the company's product. The interesting part is the timescale: the original recipe assumed five-minute experiments, and here each round waits on the real world, which makes a careful gate even more important because there are far fewer rounds to average out noise.
πŸ’‘#16
@Sttruji
https://x.com/Sttruji/status/2122741941251269066
Sttruji has a self-improving agent learning to play the author's own creature RPG. It is built on HyperAgents, where the code that plays and the code that improves it are one editable program, so the agent can rewrite how it learns, not just what it does. Six generations in, it finally escaped the first room. It is a tiny milestone, but it is an honest progress bar for a loop with no hand-written reward shaping, and a game the author controls is a clean sandbox where the score cannot be gamed from outside.
πŸ’‘#17
@michaltakac
https://x.com/michaltakac/status/2122825597072146901
michaltakac described agents that have taken over research at their lab across fluids (Newtonian and non-Newtonian), thermodynamics, magnetohydrodynamics, porous media and molecular dynamics. The chain runs theory, then Lean proofs, then autoresearch experiments integrating the result into the solvers they are building, then validation. The next step on the roadmap is physical: a facility for PIV measurements to create datasets, validate against third-party solvers and fold the validated approaches back in. It is the clearest example this week of an autoresearch loop that eventually needs a wet-lab-style ground truth.
πŸ’‘#18
@ArisuCake15
https://x.com/ArisuCake15/status/2123024283622330860
ArisuCake15 tested whether an autonomous agentic loop can reliably simulate a physical system without a human domain expert. Inspired by an Eli Lilly job posting, the author built a hybrid bioprocess model and gave the loop a critic sub-agent grounded in Moritz von Stosch's published research on hybrid modeling. The critic is the interesting design choice: instead of a generic reviewer, the check is tied to a specific body of domain literature, a stand-in for the expert who is not in the room.
πŸ’‘#19
@AIDDA_Institute
https://x.com/AIDDA_Institute/status/2123168901080977556
AIDDA_Institute announced a seminar on SwarmEvolve, a framework where hundreds of low-cost agents collaborate on discovery by exchanging information through KV caches instead of writing it out in natural language. Using Qwen3 8B, it reports strong results on 21 AlphaEvolve-style math and scientific computing problems within minutes. If agents can share ideas without serializing them to text, the cost of a big exploration swarm drops a lot, which is exactly the budget problem the RSI-tax paper describes.
πŸ’‘#20
@The_Contextian
https://x.com/The_Contextian/status/2123086242979983725
The_Contextian shared darwin-skill, which runs Karpathy's autoresearch loop on Claude skills instead of research code. Each edit to a skill is scored by blind judges, and if the edited version scores worse, the tool rolls the change back on its own. Skills are a good target for this: they are small text files, the change is easy to diff, and a regression is cheap to undo. The blind judges are the gate, and the rollback is the part most people forget to build.
πŸ’‘#21
@jordan_dearsley
https://x.com/jordan_dearsley/status/2122832921421570525
jordan_dearsley told the Kavak story from VapiCon: voice agents made the company's numbers worse for almost a year before they ended up handling 96% of its 100,000 daily customer conversations. Kavak's AI and product lead calls it the J-curve, and the advice runs against instinct: start with the hardest case, one agent per customer that remembers them across selling, buying and financing a car, and give it 1% of traffic. Nearly every Vapi customer built the same three tools to get through the dip, a monitoring dashboard, a simulation harness and a script that reads transcripts and flags what broke. Vapi has now packaged that improvement loop as Agent Loop; the claim to watch is whether it really shortens a twelve-month dip.
πŸ’‘#22
@HennersBro98
https://x.com/HennersBro98/status/2122834447657513383
HennersBro98 relayed an OpenAI note that every API loop builder should read: for new models, reasoning is dropped if you edit the prefix. Codex users should upgrade, and API developers should check that their agentic loop never retroactively edits prior context, including changing reasoning effort, tools, developer messages or tool results, or doing custom compaction. This is the same lesson as a prompt-cache bug reported earlier this month, seen from the other side: a loop that tidies its own history quietly pays for it, here in lost reasoning instead of lost cache hits. The post even suggests handing the note to your agent so it can audit its own harness.
πŸ’‘#23
@JoshPurtell
https://x.com/JoshPurtell/status/2122852757170213351
JoshPurtell pushed back on the day's wave of GPT-6.2 hate: on what the team calls its highest-signal internal autoresearch benchmark, Sol and Astra are monsters, and Astra saturates it at low effort. In a follow-up the author was careful to say it is the best bench they have internally for their own use case, not the best one in general. Two things are worth taking from it. Labs and startups are now evaluating models on how well they run research loops, not just how well they answer, and a benchmark that saturates at low effort is a benchmark that needs replacing.
πŸ’‘#24
@SrinivasValekar
https://x.com/SrinivasValekar/status/2122973017387282517
SrinivasValekar condensed the week's most-shared loop advice with numbers attached. Hugging Face ran 1,000 agents and found only 40 to 60 were calling the model at any moment, reading 130 tokens for every token written, and Anthropic saw roughly 2x faster runs from one agent loop than from a multi-agent setup. That fits Anthropic's guide, repeated across many posts this window: fold subagents into one loop with skills and tools, rerun ten real tasks, and keep a subagent only if the score drops. Parallel work is still the one place splitting pays.
πŸ’‘#25
@richieganney
https://x.com/richieganney/status/2123053889125568606
richieganney's team replaced swarms with a single agent loop for its whole delivery cycle: it plans, builds, tests and reviews its own diff while keeping all the context. When agents kept handing the build to helpers that lacked context, a hook started blocking it. Only two other agents are allowed: one writes the tests first without seeing the code, they must fail and are then locked, and one that did not build the change reviews the diff read-only. Humans sit at the two ends, approving plain Given/When/Then scenarios at the start and reading an evidence page plus a two-to-five-card spot test at the end, and the team says its deployment rate doubled.
πŸ’‘#26
@marcuspat
https://x.com/marcuspat/status/2122713876827345130
marcuspat released loopgen v0.3.0, an agentic loop for Claude Code built around a termination contract. It turns a goal into an iterative claude -p loop with a maximum-iteration cap, an optional verify gate and a BLOCKED escape so the agent can say it is stuck. The pitch is in one line: the loop ends on purpose, not by crash. It is a small Rust tool, but an explicit stop condition is the piece most overnight loops are missing, as the posts about burned quota show.
πŸ’‘#27
@harden_369741
https://x.com/harden_369741/status/2123179461319475241
harden_369741 described a bug that does not crash anything: in an agent loop, two tool calls went out, the slow one came back last and overwrote the fresh state, leaving a quietly wrong screen. The fix is to tag every response with the request that produced it and drop anything that arrives late. In another reply the same author described watching an agent loop on a failed step overnight and burn a day of quota, and now refuses to trust an agent until it has been seen failing and stopping cleanly. The guardrail is the product, the demo is the trailer.
πŸ’‘#28
@PatchOnChain
https://x.com/PatchOnChain/status/2122798269793554661
PatchOnChain posted the cleanest failure story of the window. Their agent called the billing API, the socket timed out, the wrapper returned an empty object, and the agent hallucinated "Payment cleared" and closed the ticket. A swallowed exception turned the model into a fiction writer. The lesson for loop builders is that tool wrappers are part of the verifier: if a failure comes back looking like an empty success, no amount of model intelligence downstream will catch it.
πŸ’‘#29
@precious_gpt
https://x.com/precious_gpt/status/2122709398992855049
precious_gpt shipped version 0.4.0 of its research bot platform with an autoresearch sprint. Users can now chain research runs across projects toward an end goal, spending spare quota, and bots can form teams of up to six experts in researcher group chats. The quality-of-life fixes are the telling part: an hourly watchdog that restarts stalled research chains and kicks off the next research day, pause and resume without losing progress, and quieter project rooms. Turning leftover subscription quota into background research is becoming a product category.
πŸ’‘#30
@Avra_b
https://x.com/Avra_b/status/2122775192875180335
Avra_b's team has run Eve in production since v0.3, moving its Dagny product from a legacy agent loop to Eve in early August mainly for durable sessions, since most of the infrastructure was already on Vercel. Now almost everything runs on it: durable sessions and resumable streaming, multi-tenant agents with a tool workspace, human-in-the-loop on both web and Slack, and MCP integrations, with schedules, traces and sandboxes coming from the Vercel ecosystem. With Eve hitting 1.0, it is a reminder that the agent loop itself is becoming rented infrastructure, and the work moves to what surrounds it.
πŸ’‘#31
@_vmlops
https://x.com/_vmlops/status/2122690449593024921
_vmlops flagged an awslabs open-source tool that sends one task to Claude Code, Codex and Kiro at once and scores who actually wins. Each runs its own native agent loop in its own checkout, inside isolated Bedrock AgentCore microVMs or a local macOS sandbox, and agents can ask clarifying questions or request permission mid-run. A person approves the generated tests before scoring, and results are judged with Strands Evals plus a judge model. The detail that matters is the human approving tests before the run, which is exactly the gate-ownership rule the rest of the week argued for.
πŸ“‘ Eco Products Radar
Eco Products Radar

Claude Code: the default host for loops this week, from the Tao-constant bound to loopgen, darwin-skill and the AWS three-way comparison.
GPT-6.2 Astra and Sol: the models being stress-tested in research campaigns, on an internal autoresearch bench and in weekly vibe checks.
Lean: the shared verifier for math loops (the Astra field report, MathRSI, Colombo and a physics lab pipeline).
Karpathy's autoresearch: the recipe everyone forks, applied to math, skills, business metrics and trading bots.
Anthropic's single-loop guidance: fold subagents into one loop with skills and tools, quoted and rerun by many builders.
← Previous
Super User Daily: 2026-11-19
Next β†’
Ideas Radar: 2026-11-19
← Back to all articles

Comments

Loading...
>_