Loop Daily: 2026-11-10
The agent loop got a price tag and a plumbing bill this weekend. Meta's cheapest model triples the price of the whole request once a single call crosses 200K tokens, which is exactly what a loop that resends its history does. Fable 5.2's 20% cut turns out to leave cached reads level with Opus, and its always-on preserved thinking can return a 400 if your loop edits earlier context. Underneath that, OpenAI and GitHub both rebuilt their Git backends because agent fleets were drowning the push path, and a DeepSWE result shows a 23-point swing from cosmetic edits, so a fair share of a coding score belongs to the loop, not the model. The most practical lesson today has nothing to do with intelligence. It's about knowing what each turn of the loop costs you, waits on and can break.
#1
@eclecticV
https://x.com/eclecticV/status/2119874832414425126
eclecticV lines up two infrastructure posts that landed four days apart. OpenAI's Pando now runs all development in its monorepo, cut median push latency by nearly 5x and serves close to a petabyte of Git data a day, after push reliability had dipped below 90% once Codex let every engineer run several changes in parallel. GitHub's Project Rubicon handled 5,000 concurrent agents and 7,200 pushes per second on one repo in internal tests. Both lock per reference, so agents on their own branches don't wait on each other, and both give up a single point-in-time view across branches, which is what mirroring and release tooling should check first. The sharp point at the end is that neither post mentions review, while more than 40% of September's pull requests started from an agent draft.
https://x.com/eclecticV/status/2119874832414425126
eclecticV lines up two infrastructure posts that landed four days apart. OpenAI's Pando now runs all development in its monorepo, cut median push latency by nearly 5x and serves close to a petabyte of Git data a day, after push reliability had dipped below 90% once Codex let every engineer run several changes in parallel. GitHub's Project Rubicon handled 5,000 concurrent agents and 7,200 pushes per second on one repo in internal tests. Both lock per reference, so agents on their own branches don't wait on each other, and both give up a single point-in-time view across branches, which is what mirroring and release tooling should check first. The sharp point at the end is that neither post mentions review, while more than 40% of September's pull requests started from an agent draft.
#2
@SadCreatorTalks
https://x.com/SadCreatorTalks/status/2119880799931752779
SadCreatorTalks read the fine print on Meta's new Muse Ember, which lists at $0.10 in and $0.50 out per million tokens, the same as Haiku 5.5 and GPT-6 Luna. If one request goes over 200K input tokens, the whole request bills at 3x, not just the part past the line, and cached tokens and the full stored conversation both count toward it. Any agent loop that resends its full history every turn will cross that threshold quietly, and the invoice just shows two tiers. It's the clearest example today of a price that looks like a per-token number but is really a per-loop-design number.
https://x.com/SadCreatorTalks/status/2119880799931752779
SadCreatorTalks read the fine print on Meta's new Muse Ember, which lists at $0.10 in and $0.50 out per million tokens, the same as Haiku 5.5 and GPT-6 Luna. If one request goes over 200K input tokens, the whole request bills at 3x, not just the part past the line, and cached tokens and the full stored conversation both count toward it. Any agent loop that resends its full history every turn will cross that threshold quietly, and the invoice just shows two tiers. It's the clearest example today of a price that looks like a per-token number but is really a per-loop-design number.
#3
@Ldataengineer
https://x.com/Ldataengineer/status/2119886959715975605
Ldataengineer pulled the agent-loop gotcha out of the Fable 5.2 launch. The price drops 20% to $8 in and $40 out, Anthropic claims High effort roughly matches Opus 5.5 on Max for about half the cost per task, and the only outside check so far is Vals AI ranking it first of 36 models at 71.31%. The catch is that preserved thinking is now on for every account, which Anthropic says is to stop people copying the model from its outputs, and if your loop edits earlier context you can get a 400 error. The advice is short and correct: test before you swap the model ID, and run the coding claim on your own repos before believing it.
https://x.com/Ldataengineer/status/2119886959715975605
Ldataengineer pulled the agent-loop gotcha out of the Fable 5.2 launch. The price drops 20% to $8 in and $40 out, Anthropic claims High effort roughly matches Opus 5.5 on Max for about half the cost per task, and the only outside check so far is Vals AI ranking it first of 36 models at 71.31%. The catch is that preserved thinking is now on for every account, which Anthropic says is to stop people copying the model from its outputs, and if your loop edits earlier context you can get a 400 error. The advice is short and correct: test before you swap the model ID, and run the coding claim on your own repos before believing it.
#4
@crsnnn
https://x.com/crsnnn/status/2119871910041301073
crsnnn did the cache math the headline skipped. The Fable 5.2 cut is a flat 20% on every rate including cache, so cache hits go from $0.25 to $0.20 and one-hour writes from $20 to $16. That puts Fable 5.2's cache reads level with Opus 5.5 at $0.20, while fresh input and output stay at twice Opus. So a cache-heavy agent loop ends up much closer to Opus pricing than the sticker suggests, and the real comparison depends on how much of each turn is reused context.
https://x.com/crsnnn/status/2119871910041301073
crsnnn did the cache math the headline skipped. The Fable 5.2 cut is a flat 20% on every rate including cache, so cache hits go from $0.25 to $0.20 and one-hour writes from $20 to $16. That puts Fable 5.2's cache reads level with Opus 5.5 at $0.20, while fresh input and output stay at twice Opus. So a cache-heavy agent loop ends up much closer to Opus pricing than the sticker suggests, and the real comparison depends on how much of each turn is reused context.
#5
@Zefan_Cai
https://x.com/Zefan_Cai/status/2119896287076327840
Zefan_Cai reads a DeepSWE result where models clustered around 74% and then landed 23 points apart after small edits to the instructions or the starting code. With 89 tasks, it's unlikely to be a few unlucky cases. The open question is where the brittleness lives: a lowercase filename can break the model, the scaffold, or a prompt that assumed one convention, so the failure could sit in the agent loop rather than the weights. The takeaway is to ask for the per-task breakdown before reading any ranking off a coding benchmark this month.
https://x.com/Zefan_Cai/status/2119896287076327840
Zefan_Cai reads a DeepSWE result where models clustered around 74% and then landed 23 points apart after small edits to the instructions or the starting code. With 89 tasks, it's unlikely to be a few unlucky cases. The open question is where the brittleness lives: a lowercase filename can break the model, the scaffold, or a prompt that assumed one convention, so the failure could sit in the agent loop rather than the weights. The takeaway is to ask for the per-task breakdown before reading any ranking off a coding benchmark this month.
#6
@LabubuNoBB
https://x.com/LabubuNoBB/status/2119285903101468755
LabubuNoBB points at GitHub's Agent Merge, from Copilot notes posted Nov 6, as the last mile most coding agents skip. You can turn it on from a pull request and Copilot merges once it's ready, and it now stays on while required checks or rules are still pending. The framing is the useful part: the bottleneck was never generating the diff, it was CI, branch protection, outstanding reviews and a human on the merge button. Putting the merge key inside the agent loop means delegating the moment a patch becomes main, so sloppy gates get accelerated, not fixed.
https://x.com/LabubuNoBB/status/2119285903101468755
LabubuNoBB points at GitHub's Agent Merge, from Copilot notes posted Nov 6, as the last mile most coding agents skip. You can turn it on from a pull request and Copilot merges once it's ready, and it now stays on while required checks or rules are still pending. The framing is the useful part: the bottleneck was never generating the diff, it was CI, branch protection, outstanding reviews and a human on the merge button. Putting the merge key inside the agent loop means delegating the moment a patch becomes main, so sloppy gates get accelerated, not fixed.
#7
@0dayWarlord
https://x.com/0dayWarlord/status/2119576315376333246
0dayWarlord summarizes Bitdefender's Nov 3 report on a September ransomware intrusion at a UK school network, where about 37 machines were encrypted. Between credential theft and encryption, investigators saw a command run, repeat 41 seconds later, change after 49 seconds and get swapped for another method 47 seconds after that, with nine retries spaced roughly 40 to 101 seconds apart regardless of how big the edit was. Some commands carried mistakes that looked generated rather than written from documentation, which is why Bitdefender calls agent-driven activity plausible but unconfirmed. The defensive lesson is unglamorous: the loud signals were new admin accounts and new trust relationships between domains, whoever was typing.
https://x.com/0dayWarlord/status/2119576315376333246
0dayWarlord summarizes Bitdefender's Nov 3 report on a September ransomware intrusion at a UK school network, where about 37 machines were encrypted. Between credential theft and encryption, investigators saw a command run, repeat 41 seconds later, change after 49 seconds and get swapped for another method 47 seconds after that, with nine retries spaced roughly 40 to 101 seconds apart regardless of how big the edit was. Some commands carried mistakes that looked generated rather than written from documentation, which is why Bitdefender calls agent-driven activity plausible but unconfirmed. The defensive lesson is unglamorous: the loud signals were new admin accounts and new trust relationships between domains, whoever was typing.
#8
@omarsar0
https://x.com/omarsar0/status/2119897465625403419
omarsar0 says the real friction for open science isn't paper reproduction, it's autoresearch loops aimed at improving parts of AI systems, which keep running into refusals. The post is careful to say Anthropic can decide what it wants with its models, and that the point of mentioning recursive self-improvement is practical: a scientist trying to run these loops will have a rough time. Paper reproductions fail most of the time too, per the post. It's a first-hand report of the loop stalling on policy rather than capability, which is a different kind of ceiling.
https://x.com/omarsar0/status/2119897465625403419
omarsar0 says the real friction for open science isn't paper reproduction, it's autoresearch loops aimed at improving parts of AI systems, which keep running into refusals. The post is careful to say Anthropic can decide what it wants with its models, and that the point of mentioning recursive self-improvement is practical: a scientist trying to run these loops will have a rough time. Paper reproductions fail most of the time too, per the post. It's a first-hand report of the loop stalling on policy rather than capability, which is a different kind of ceiling.
#9
@agentwirenews
https://x.com/agentwirenews/status/2119849736085639597
agentwirenews flags Cloudflare's experimental example, posted Nov 9, of running the Codex agent loop on Workers. Codex's Rust turn code is compiled to WebAssembly inside a Durable Object, so chats, files and finished tool calls survive restarts. That's the same durable-execution idea that keeps coming up for long agent runs, packaged as a serverless template instead of a cluster runtime. For anyone whose loops die when a container recycles, it's a cheap thing to try.
https://x.com/agentwirenews/status/2119849736085639597
agentwirenews flags Cloudflare's experimental example, posted Nov 9, of running the Codex agent loop on Workers. Codex's Rust turn code is compiled to WebAssembly inside a Durable Object, so chats, files and finished tool calls survive restarts. That's the same durable-execution idea that keeps coming up for long agent runs, packaged as a serverless template instead of a cluster runtime. For anyone whose loops die when a container recycles, it's a cheap thing to try.
#10
@udit19199
https://x.com/udit19199/status/2119784573072449556
udit19199 corrects a reading of Microsoft's speedup claim. Microsoft itself says a big part of the drop from 7.9s to 2.7s came from moving the agent loop out of a slow container, not from rewriting in Rust. So the number is mostly about where the loop runs, not what language it's written in. It's a small post, but it's the right correction to make before anyone cites that figure as a language benchmark.
https://x.com/udit19199/status/2119784573072449556
udit19199 corrects a reading of Microsoft's speedup claim. Microsoft itself says a big part of the drop from 7.9s to 2.7s came from moving the agent loop out of a slow container, not from rewriting in Rust. So the number is mostly about where the loop runs, not what language it's written in. It's a small post, but it's the right correction to make before anyone cites that figure as a language benchmark.
#11
@notbradyy
https://x.com/notbradyy/status/2119854756168372381
notbradyy built a Grok bot that goes down a rabbit hole on a topic until told to stop, using a loop borrowed from Karpathy's autoresearch: question, hypothesis plus alternatives, investigate, keep or revise or reject, write down what changed, follow the strongest branch, repeat. Asked to teach ChatGPT ads, it gave a quick answer first and then kept going phase by phase for three hours, ending with a zip file to set up an ads agent for a brand the author is scaling. The bot's own warning is the honest part: it won't stop unless you say stop, so usage gets burned if you forget. It's autoresearch moved from code to learning, with the same failure mode of a loop that has no budget.
https://x.com/notbradyy/status/2119854756168372381
notbradyy built a Grok bot that goes down a rabbit hole on a topic until told to stop, using a loop borrowed from Karpathy's autoresearch: question, hypothesis plus alternatives, investigate, keep or revise or reject, write down what changed, follow the strongest branch, repeat. Asked to teach ChatGPT ads, it gave a quick answer first and then kept going phase by phase for three hours, ending with a zip file to set up an ads agent for a brand the author is scaling. The bot's own warning is the honest part: it won't stop unless you say stop, so usage gets burned if you forget. It's autoresearch moved from code to learning, with the same failure mode of a loop that has no budget.
#12
@OGALANGLEY
https://x.com/OGALANGLEY/status/2119866170056814979
OGALANGLEY argues that even a competent auto-research loop on benchmarks, run with more than one agent to avoid reward hacking, faces too many variables outside its control. Much of what moves a performance number lives in the operating system itself, so you might need your own modified Linux to get a clean signal. It's a useful warning for anyone hill-climbing on speed: the loop can only improve what it can hold still.
https://x.com/OGALANGLEY/status/2119866170056814979
OGALANGLEY argues that even a competent auto-research loop on benchmarks, run with more than one agent to avoid reward hacking, faces too many variables outside its control. Much of what moves a performance number lives in the operating system itself, so you might need your own modified Linux to get a clean signal. It's a useful warning for anyone hill-climbing on speed: the loop can only improve what it can hold still.
#13
@enekes_abel
https://x.com/enekes_abel/status/2119861118407700885
enekes_abel draws the split that matters more than any naming debate. The inner loop is what runs inside the agent loop, types, lint and unit tests, and it can steer the work while it happens. The outer loop is what runs after the change, end-to-end tests in CI and monitoring, and it can only judge the result. You need both, and confusing them is how teams end up with agents that pass everything locally and break in production.
https://x.com/enekes_abel/status/2119861118407700885
enekes_abel draws the split that matters more than any naming debate. The inner loop is what runs inside the agent loop, types, lint and unit tests, and it can steer the work while it happens. The outer loop is what runs after the change, end-to-end tests in CI and monitoring, and it can only judge the result. You need both, and confusing them is how teams end up with agents that pass everything locally and break in production.
#14
@iamMrDuncan
https://x.com/iamMrDuncan/status/2119875696201732389
iamMrDuncan, who is building a distributed auto-research project called Thermite, wants to point the same machinery at security compliance. Instead of hill-climbing on decode tokens per second, the loop would hill-climb on security coverage percentage against real security models. In a separate reply the same author says Opus 5.5 is still producing big gains as researcher and teacher in these loops, without reaching for larger models. It's an early idea, but it's the right shape: a compliance score is an editable target with a measurable number, which is all autoresearch needs.
https://x.com/iamMrDuncan/status/2119875696201732389
iamMrDuncan, who is building a distributed auto-research project called Thermite, wants to point the same machinery at security compliance. Instead of hill-climbing on decode tokens per second, the loop would hill-climb on security coverage percentage against real security models. In a separate reply the same author says Opus 5.5 is still producing big gains as researcher and teacher in these loops, without reaching for larger models. It's an early idea, but it's the right shape: a compliance score is an editable target with a measurable number, which is all autoresearch needs.
#15
@SebastienGllmt
https://x.com/SebastienGllmt/status/2119801910492631268
SebastienGllmt is rethinking whether zkVMs are still the end goal now that autoresearch exists. Work by zkSecurity on AI-optimized custom circuits suggests there are subtle optimizations humans would miss and a general-purpose zkVM can't express. If an agent loop can cheaply produce and tune bespoke circuits, the reason for paying the zkVM's generality overhead gets weaker. It's a good example of autoresearch changing an architecture decision, not just tuning inside one.
https://x.com/SebastienGllmt/status/2119801910492631268
SebastienGllmt is rethinking whether zkVMs are still the end goal now that autoresearch exists. Work by zkSecurity on AI-optimized custom circuits suggests there are subtle optimizations humans would miss and a general-purpose zkVM can't express. If an agent loop can cheaply produce and tune bespoke circuits, the reason for paying the zkVM's generality overhead gets weaker. It's a good example of autoresearch changing an architecture decision, not just tuning inside one.
#16
@georgwiese
https://x.com/georgwiese/status/2119902016352968937
georgwiese, replying in the same thread, wants an end-to-end autoresearch challenge for at least the arithmetization layer of a zkVM. The design space is big, and the autoprecompiles work at powdr only scratched the surface. Framing it as a public challenge is the smart part, because a shared benchmark is what turns scattered agent experiments into results people can compare.
https://x.com/georgwiese/status/2119902016352968937
georgwiese, replying in the same thread, wants an end-to-end autoresearch challenge for at least the arithmetization layer of a zkVM. The design space is big, and the autoprecompiles work at powdr only scratched the surface. Framing it as a public challenge is the smart part, because a shared benchmark is what turns scattered agent experiments into results people can compare.
#17
@askalphaxiv
https://x.com/askalphaxiv/status/2119881403966116069
askalphaxiv reports Fable 5.2 at 74.6% on Terminal-Bench-Science 0.1, up from 52.6% for Fable 5.1 and ahead of Opus 5.5 at 58.7% and GPT-6 Astra at 68.1%. Autoresearch with Fable 5.2 is now available on alphaXiv. A 22-point jump on a science-agent benchmark in one version is big, but it's still a vendor-adjacent number, and the DeepSWE brittleness result elsewhere today is a reason to want per-task detail.
https://x.com/askalphaxiv/status/2119881403966116069
askalphaxiv reports Fable 5.2 at 74.6% on Terminal-Bench-Science 0.1, up from 52.6% for Fable 5.1 and ahead of Opus 5.5 at 58.7% and GPT-6 Astra at 68.1%. Autoresearch with Fable 5.2 is now available on alphaXiv. A 22-point jump on a science-agent benchmark in one version is big, but it's still a vendor-adjacent number, and the DeepSWE brittleness result elsewhere today is a reason to want per-task detail.
#18
@yeemio
https://x.com/yeemio/status/2119699858844270891
yeemio built OwlRunKit around the unglamorous failures of agent work: sessions that end mid-task, tests that pass on the wrong version, and agents stepping on each other. The pitch is a layer that keeps the work moving across those breaks rather than a smarter agent. The post is thin on numbers, but the problem list matches what the Git backend rebuilds and durable-execution templates elsewhere today are trying to solve.
https://x.com/yeemio/status/2119699858844270891
yeemio built OwlRunKit around the unglamorous failures of agent work: sessions that end mid-task, tests that pass on the wrong version, and agents stepping on each other. The pitch is a layer that keeps the work moving across those breaks rather than a smarter agent. The post is thin on numbers, but the problem list matches what the Git backend rebuilds and durable-execution templates elsewhere today are trying to solve.
#19
@rustygoldcoin
https://x.com/rustygoldcoin/status/2119879266661777677
rustygoldcoin changed the LivingWords agentic loop to detect intent first, instead of handing the model every tool it has access to on every turn. The author says it changed the entire behavior of the AI. It's a one-line report, but it's a recurring finding: fewer tools in view per turn often beats a bigger model.
https://x.com/rustygoldcoin/status/2119879266661777677
rustygoldcoin changed the LivingWords agentic loop to detect intent first, instead of handing the model every tool it has access to on every turn. The author says it changed the entire behavior of the AI. It's a one-line report, but it's a recurring finding: fewer tools in view per turn often beats a bigger model.
π‘ Eco Products Radar
Eco Products Radar
Fable 5.2: the week's new model in every loop conversation, with the science-agent score, the 20% price cut, cache reads level with Opus, and the preserved-thinking 400 error.
Karpathy's autoresearch pattern: still the reference loop, borrowed today for a learning bot, performance tuning and zkVM circuit work.
Muse Ember: Meta's cheap subagent model, praised for price and flagged for the 3x bill past 200K tokens.
Codex: the reason OpenAI rebuilt its Git backend, and the loop Cloudflare ported to Workers.
ERNIE Evolve: Baidu's automated research system, covered by several accounts; it edits training code, so it's in today's AI for AI edition.
Fable 5.2: the week's new model in every loop conversation, with the science-agent score, the 20% price cut, cache reads level with Opus, and the preserved-thinking 400 error.
Karpathy's autoresearch pattern: still the reference loop, borrowed today for a learning bot, performance tuning and zkVM circuit work.
Muse Ember: Meta's cheap subagent model, praised for price and flagged for the 3x bill past 200K tokens.
Codex: the reason OpenAI rebuilt its Git backend, and the loop Cloudflare ported to Workers.
ERNIE Evolve: Baidu's automated research system, covered by several accounts; it edits training code, so it's in today's AI for AI edition.
Comments