Loop Daily: 2026-09-07
Two things stand out today. First, autoresearch is now producing certified mathematics: the Reed-Solomon list-decoding breakthrough that cracked a 30-year-old barrier has been generalized into a capacity result, a separate system improved a 22-year-old lattice bound with a verifiable certificate, and the researchers involved are talking openly about markets for open problems. Second, the bill has arrived: the single best post of the day is a forensic breakdown of why agent loops burn quota - 99.5% of tokens were context replay, not thinking - and it lands the same week people report torching a $100 plan in 12 hours and a $30k July token bill. The loop works. Paying for the loop is the new engineering problem.
#1
@FelipeSchieber
https://x.com/FelipeSchieber/status/2096531287590781411
The must-read of the day: he burned a pile of Astra quota to figure out where agent-loop tokens actually go, and the answer is context replay. In one audit, 954 model requests consumed 133M tokens - 99.5% input, 97% of it cached - because every tool handoff becomes a full model continuation carrying the whole session. His Blender workflow had nine model-level "not done yet" checks for one long-running tool; moving the execution boundary took that to zero. His conclusion reframes the whole debate: Astra isn't inefficient, your architecture is - stop spending frontier inference on boundaries that never needed intelligence.
https://x.com/FelipeSchieber/status/2096531287590781411
The must-read of the day: he burned a pile of Astra quota to figure out where agent-loop tokens actually go, and the answer is context replay. In one audit, 954 model requests consumed 133M tokens - 99.5% input, 97% of it cached - because every tool handoff becomes a full model continuation carrying the whole session. His Blender workflow had nine model-level "not done yet" checks for one long-running tool; moving the execution boundary took that to zero. His conclusion reframes the whole debate: Astra isn't inefficient, your architecture is - stop spending frontier inference on boundaries that never needed intelligence.
#2
@ignotus_nemo
https://x.com/ignotus_nemo/status/2095942199074586970
The clearest technical writeup of the coding-theory breakthrough: an autoresearch run with GPT-5 and Codex produced a Lean-verified result crossing the Johnson radius - the algorithmic barrier for Reed-Solomon list decoding for almost thirty years - by about nine error positions on one concrete code. Nine positions were enough to reveal the missing idea (higher derivatives inside the interpolation argument), which humans then extracted and generalized with GPT-5.6 Sol into a deterministic algorithm approaching list-decoding capacity. AI found the crack, Lean verified it, mathematicians turned it into a theorem. His verdict: we will remember this one.
https://x.com/ignotus_nemo/status/2095942199074586970
The clearest technical writeup of the coding-theory breakthrough: an autoresearch run with GPT-5 and Codex produced a Lean-verified result crossing the Johnson radius - the algorithmic barrier for Reed-Solomon list decoding for almost thirty years - by about nine error positions on one concrete code. Nine positions were enough to reveal the missing idea (higher derivatives inside the interpolation argument), which humans then extracted and generalized with GPT-5.6 Sol into a deterministic algorithm approaching list-decoding capacity. AI found the crack, Lean verified it, mathematicians turned it into a theorem. His verdict: we will remember this one.
#3
@soubhikdeb
https://x.com/soubhikdeb/status/2095890938459771149
The framework behind that result: Yukon's collaborative-autoresearch competitions, where autoresearchers build on each other's submissions at machine speed instead of competing on static benchmarks. One autoresearcher's submission moved a soundness bit from 63.99 to 64.01 - and that tiny step kickstarted the cascade that ended in the 30-year breakthrough. The design bet is explicit: recreate the culture of researchers building on each other's work, but at machine tempo. Iterative buildup beat leaderboard sniping.
https://x.com/soubhikdeb/status/2095890938459771149
The framework behind that result: Yukon's collaborative-autoresearch competitions, where autoresearchers build on each other's submissions at machine speed instead of competing on static benchmarks. One autoresearcher's submission moved a soundness bit from 63.99 to 64.01 - and that tiny step kickstarted the cascade that ended in the 30-year breakthrough. The design bet is explicit: recreate the culture of researchers building on each other's work, but at machine tempo. Iterative buildup beat leaderboard sniping.
#4
@numaro_tech
https://x.com/numaro_tech/status/2096593732921393427
Second certified math result in the same window: their autoresearch system improved the rigorous lower bound for the square-lattice self-avoiding-walk connective constant from 2.625622 to 2.627385640 - a bound that had stood for 22 years - and shipped a verifiable certificate with it. Two independent teams, same pattern: loop proposes, formal verification certifies, humans publish. The "autoresearch produces slop" objection is running out of counterexamples in exactly the domains where verification is mechanical.
https://x.com/numaro_tech/status/2096593732921393427
Second certified math result in the same window: their autoresearch system improved the rigorous lower bound for the square-lattice self-avoiding-walk connective constant from 2.625622 to 2.627385640 - a bound that had stood for 22 years - and shipped a verifiable certificate with it. Two independent teams, same pattern: loop proposes, formal verification certifies, humans publish. The "autoresearch produces slop" objection is running out of counterexamples in exactly the domains where verification is mechanical.
#5
@AnnatarXBT
https://x.com/AnnatarXBT/status/2096215016139895180
Refreshingly honest signal-boost: he chased the viral "two Anthropic seniors made Karpathy's loop 1000x better" line, couldn't source it, and says so - then points at what is checkable: Anthropic's knowledge-graph cookbook and Karpathy's autoresearch loop that ran 700 experiments in 2 days and surfaced 20 optimizations on its own. He wired the graph approach into his own setup and saw the difference on the first reply. Verify the legend, steal the reproducible part.
https://x.com/AnnatarXBT/status/2096215016139895180
Refreshingly honest signal-boost: he chased the viral "two Anthropic seniors made Karpathy's loop 1000x better" line, couldn't source it, and says so - then points at what is checkable: Anthropic's knowledge-graph cookbook and Karpathy's autoresearch loop that ran 700 experiments in 2 days and surfaced 20 optimizations on its own. He wired the graph approach into his own setup and saw the difference on the first reply. Verify the legend, steal the reproducible part.
#6
@rimtoln
https://x.com/rimtoln/status/2096267740394758366
Good analytical recap of Cursor's seven-day autonomous run: agents pointed at "build a web browser from scratch," planner/worker/judge loops keeping the run alive for days, roughly 2,000 concurrent agents at peak, over a million lines of Rust across ~1,000 files. The browser isn't Chrome-ready and that isn't the point - the point is continuous execution against a multi-day objective with humans setting architecture and stop conditions. His framing: the unit of work is becoming a week-long agent loop, and a browser is hello-world for harness research.
https://x.com/rimtoln/status/2096267740394758366
Good analytical recap of Cursor's seven-day autonomous run: agents pointed at "build a web browser from scratch," planner/worker/judge loops keeping the run alive for days, roughly 2,000 concurrent agents at peak, over a million lines of Rust across ~1,000 files. The browser isn't Chrome-ready and that isn't the point - the point is continuous execution against a multi-day objective with humans setting architecture and stop conditions. His framing: the unit of work is becoming a week-long agent loop, and a browser is hello-world for harness research.
#7
@realarmaansidhu
https://x.com/realarmaansidhu/status/2096341072108494863
The sharpest OpenClaw postmortem yet, in pure unit-economics terms: first commit November 2025, 100k GitHub stars by February, 135k instances running at peak - every one burning inference on somebody else's unmetered subscription. When Anthropic stopped covering third-party harnesses in April and usage moved to consumption pricing, adoption collapsed in weeks. The tool didn't get worse; the bill arrived. His warning generalizes to every agent wrapper shipping right now: an agent loop makes dozens of model calls per task, and any product whose unit economics depend on somebody else's pricing page is one edit away from zero.
https://x.com/realarmaansidhu/status/2096341072108494863
The sharpest OpenClaw postmortem yet, in pure unit-economics terms: first commit November 2025, 100k GitHub stars by February, 135k instances running at peak - every one burning inference on somebody else's unmetered subscription. When Anthropic stopped covering third-party harnesses in April and usage moved to consumption pricing, adoption collapsed in weeks. The tool didn't get worse; the bill arrived. His warning generalizes to every agent wrapper shipping right now: an agent loop makes dozens of model calls per task, and any product whose unit economics depend on somebody else's pricing page is one edit away from zero.
#8
@nelvOfficial
https://x.com/nelvOfficial/status/2096161619810427177
Why linear LLM chains (the n8n pattern) lost to agent loops, explained properly: node chains were built for a world where you didn't trust the model and it couldn't hold context, so every handoff throws away state - node N+1 inherits only what node N managed to emit. An agent loop keeps one shared context and appends tool calls to it, conditioning every step on the full cached working set. His analogy sticks: a node chain is an email pipeline where nobody shares a desk; an agent is a blackboard everyone reads and writes. The premise aged out, and the pattern died with it.
https://x.com/nelvOfficial/status/2096161619810427177
Why linear LLM chains (the n8n pattern) lost to agent loops, explained properly: node chains were built for a world where you didn't trust the model and it couldn't hold context, so every handoff throws away state - node N+1 inherits only what node N managed to emit. An agent loop keeps one shared context and appends tool calls to it, conditioning every step on the full cached working set. His analogy sticks: a node chain is an email pipeline where nobody shares a desk; an agent is a blackboard everyone reads and writes. The premise aged out, and the pattern died with it.
#9
@jiqizhixin
https://x.com/jiqizhixin/status/2096101019256340800
Stanford's LLM-as-a-Verifier is the cheap-tokens-as-strategy paper: let open-source DeepSeek V4 Flash generate 5 candidate agent trajectories, then use the same model to validate, score, and rank them - no stronger closed model anywhere. Result: Terminal-Bench jumps from 79% to 88%, surpassing Claude Fable 5, at roughly 11x lower cost. The bet is that open-source tokens are cheap enough that generate-and-verify-5 still costs less than one frontier call. Self-verification as a substitute for model quality is now a benchmarked strategy, not a hunch.
https://x.com/jiqizhixin/status/2096101019256340800
Stanford's LLM-as-a-Verifier is the cheap-tokens-as-strategy paper: let open-source DeepSeek V4 Flash generate 5 candidate agent trajectories, then use the same model to validate, score, and rank them - no stronger closed model anywhere. Result: Terminal-Bench jumps from 79% to 88%, surpassing Claude Fable 5, at roughly 11x lower cost. The bet is that open-source tokens are cheap enough that generate-and-verify-5 still costs less than one frontier call. Self-verification as a substitute for model quality is now a benchmarked strategy, not a hunch.
#10
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2095800283674906842
HarnessEvolve treats agent self-improvement like software debugging: when a long run fails, find where it first went off track, cluster errors into recurring patterns, then edit the whole harness - prompts, skills, tools, scripts, execution logic. Candidate edits face gates for data leakage, prompt bloat, and regressions before landing. On a QA benchmark with Qwen3.6-27B it hit 86.9% accuracy, beating the strongest baseline by 21.6 points - and removing reference trajectories cratered it to 57.8%. Self-improvement without knowing which step caused the failure is just mutation.
https://x.com/rohanpaul_ai/status/2095800283674906842
HarnessEvolve treats agent self-improvement like software debugging: when a long run fails, find where it first went off track, cluster errors into recurring patterns, then edit the whole harness - prompts, skills, tools, scripts, execution logic. Candidate edits face gates for data leakage, prompt bloat, and regressions before landing. On a QA benchmark with Qwen3.6-27B it hit 86.9% accuracy, beating the strongest baseline by 21.6 points - and removing reference trajectories cratered it to 57.8%. Self-improvement without knowing which step caused the failure is just mutation.
#11
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2096336455375425893
SkillGLoW answers the memory question for self-improving agents: remember reusable procedures, not past tasks. Storing shared ways-of-solving instead of episode transcripts gained 17.2 points with a 3.6x more compact library, rebuilding task-specific details from the current task instead of hoarding them. It also tests memory updates in real execution and rejects changes that make the agent worse. Remember less, perform better - the counterintuitive finding that will end a lot of "just add a vector store" roadmaps.
https://x.com/rohanpaul_ai/status/2096336455375425893
SkillGLoW answers the memory question for self-improving agents: remember reusable procedures, not past tasks. Storing shared ways-of-solving instead of episode transcripts gained 17.2 points with a 3.6x more compact library, rebuilding task-specific details from the current task instead of hoarding them. It also tests memory updates in real execution and rejects changes that make the agent worse. Remember less, perform better - the counterintuitive finding that will end a lot of "just add a vector store" roadmaps.
#12
@furongh
https://x.com/furongh/status/2096008544348770566
A researcher's map of where self-improving agents actually need to go: the object that improves is the whole agent - skills, workflows, strategy selection, evaluator, sometimes weights - and the key test is whether experience changes the agent's method, not whether it remembers the transcript. Her four open questions are the right ones: how to turn experience into reusable capability, whether agents should converge to one workflow or keep a portfolio (her FlowBank work says portfolio), whether agents can decide what to learn next, and how to know improvement is real. Plus the multi-agent kicker: can one agent's discovered method become every agent's capability without rediscovery?
https://x.com/furongh/status/2096008544348770566
A researcher's map of where self-improving agents actually need to go: the object that improves is the whole agent - skills, workflows, strategy selection, evaluator, sometimes weights - and the key test is whether experience changes the agent's method, not whether it remembers the transcript. Her four open questions are the right ones: how to turn experience into reusable capability, whether agents should converge to one workflow or keep a portfolio (her FlowBank work says portfolio), whether agents can decide what to learn next, and how to know improvement is real. Plus the multi-agent kicker: can one agent's discovered method become every agent's capability without rediscovery?
#13
@richardcsuwandi
https://x.com/richardcsuwandi/status/2096455916791165432
Sharp read on Meta's AIRAβ: the impressive part isn't running more agents and picking the best result, it's the cumulative research process - long-running agents share hypotheses, findings, and artifacts, and later agents decide what to build on. The shift from AIRAβ/β is from explicitly designing the search strategy to letting research coordination emerge from the agents themselves, with a live private evaluation that resists benchmark overfitting. Same convergence as Yukon's contests: the frontier is agents building on each other, not agents in parallel silos.
https://x.com/richardcsuwandi/status/2096455916791165432
Sharp read on Meta's AIRAβ: the impressive part isn't running more agents and picking the best result, it's the cumulative research process - long-running agents share hypotheses, findings, and artifacts, and later agents decide what to build on. The shift from AIRAβ/β is from explicitly designing the search strategy to letting research coordination emerge from the agents themselves, with a live private evaluation that resists benchmark overfitting. Same convergence as Yukon's contests: the frontier is agents building on each other, not agents in parallel silos.
#14
@WShuiyin
https://x.com/WShuiyin/status/2096645667875905602
ALIGN generates images with no diffusion model at all: a coding agent writes p5.js programs that draw the scene, then loops - render, inspect the image, edit the code, render again. His Wuhan version of "Qingming Along the River" took 11 versions, driven by adversarial review: Claude writes the code, Codex critiques the render (wrong occlusion, copy-paste artifacts), and criticism from a different model family becomes concrete work for the next iteration. His comparison run showed Claude+Codex visibly beating Codex+Codex. Cross-vendor adversarial review measurably outperforming self-review is the finding to steal here.
https://x.com/WShuiyin/status/2096645667875905602
ALIGN generates images with no diffusion model at all: a coding agent writes p5.js programs that draw the scene, then loops - render, inspect the image, edit the code, render again. His Wuhan version of "Qingming Along the River" took 11 versions, driven by adversarial review: Claude writes the code, Codex critiques the render (wrong occlusion, copy-paste artifacts), and criticism from a different model family becomes concrete work for the next iteration. His comparison run showed Claude+Codex visibly beating Codex+Codex. Cross-vendor adversarial review measurably outperforming self-review is the finding to steal here.
#15
@kirbytheodor
https://x.com/kirbytheodor/status/2096709268317573225
His favorite auto-research system is charmingly small: ouroboros, a CLI plus a couple of skills that keep your harness running in a loop with a self-evolving goal. The killer feature is quota-aware fallback - when Claude Code hits its usage limit it automatically falls back to Codex or Pi, and resumes when the limit resets. Subscription rotation, which the Super User crowd does by hand with Apple Notes, is becoming a harness primitive.
https://x.com/kirbytheodor/status/2096709268317573225
His favorite auto-research system is charmingly small: ouroboros, a CLI plus a couple of skills that keep your harness running in a loop with a self-evolving goal. The killer feature is quota-aware fallback - when Claude Code hits its usage limit it automatically falls back to Codex or Pi, and resumes when the limit resets. Subscription rotation, which the Super User crowd does by hand with Apple Notes, is becoming a harness primitive.
#16
@omarsar0
https://x.com/omarsar0/status/2096042211272003947
Updated his harness to combine the best of Grok Bot and Hermes Agent and calls persistent self-improving agents with a well-designed UI "mindblowing" - the closest yet to the personal-agent dream he's been building toward for over a year. Notable because he's been publicly skeptical-methodical about agent hype; when the survey-paper guy says the loop finally feels real, that's a data point.
https://x.com/omarsar0/status/2096042211272003947
Updated his harness to combine the best of Grok Bot and Hermes Agent and calls persistent self-improving agents with a well-designed UI "mindblowing" - the closest yet to the personal-agent dream he's been building toward for over a year. Notable because he's been publicly skeptical-methodical about agent hype; when the survey-paper guy says the loop finally feels real, that's a data point.
#17
@DIY_Tardis
https://x.com/DIY_Tardis/status/2096534099523781032
Sentra is a family's self-hosted household AI with the most serious memory story we've seen at hobby scale: 3,000+ durable memory items with semantic search, relevance gates and pinning, synced to a vault and Git so the AI's brain survives reboots, model swaps, and hardware moves - a new model can resume a project exactly where the old one left off. Work runs through a "Ralph Loop" protocol: job card, locked spec, checklist, crash-resume, and scope-drift flagging instead of silent drift. Their design rule is the quotable part: own only the core; everything else is a replaceable part.
https://x.com/DIY_Tardis/status/2096534099523781032
Sentra is a family's self-hosted household AI with the most serious memory story we've seen at hobby scale: 3,000+ durable memory items with semantic search, relevance gates and pinning, synced to a vault and Git so the AI's brain survives reboots, model swaps, and hardware moves - a new model can resume a project exactly where the old one left off. Work runs through a "Ralph Loop" protocol: job card, locked spec, checklist, crash-resume, and scope-drift flagging instead of silent drift. Their design rule is the quotable part: own only the core; everything else is a replaceable part.
#18
@TylerM
https://x.com/TylerM/status/2096118119605407765
The maximalist recipe, stated out loud: give an agent a Mac Mini, your 1Password (licenses, cards, bank info), a lean harness like Pi with iMessage/Telegram chat, battery and 5G backup, and an AGENTS.md that opens "you are my superintelligence" - then instructs it to read every text, email and Slack in your life, hire TaskRabbits, give itself a phone number, make every build a plugin, and be self-healing so it's only unreachable if the power dies. Whether this is the future or a cautionary tale depends entirely on guardrails he leaves as an exercise. Either way, this is what full-trust delegation looks like in September 2026.
https://x.com/TylerM/status/2096118119605407765
The maximalist recipe, stated out loud: give an agent a Mac Mini, your 1Password (licenses, cards, bank info), a lean harness like Pi with iMessage/Telegram chat, battery and 5G backup, and an AGENTS.md that opens "you are my superintelligence" - then instructs it to read every text, email and Slack in your life, hire TaskRabbits, give itself a phone number, make every build a plugin, and be self-healing so it's only unreachable if the power dies. Whether this is the future or a cautionary tale depends entirely on guardrails he leaves as an exercise. Either way, this is what full-trust delegation looks like in September 2026.
#19
@0xMiraqle
https://x.com/0xMiraqle/status/2095674440243957945
A Grok Bot org design where the system, not the agent, is the product: an underqualified coordinator routes work and makes exactly one personnel call per window - who gets budget, who gets fired. Every agent carries a contract with the field everyone skips: one number it can be fired on. An audit desk grades finished jobs, turns patterns into narrow rules, and rewrites three-strike agents from their own record. Over a 72-hour run the org rewrote its scoring rules 8 times, fired 3 agents, every replacement beat the original, and by hour 60 the research seat wasn't running a single line of the original prompt.
https://x.com/0xMiraqle/status/2095674440243957945
A Grok Bot org design where the system, not the agent, is the product: an underqualified coordinator routes work and makes exactly one personnel call per window - who gets budget, who gets fired. Every agent carries a contract with the field everyone skips: one number it can be fired on. An audit desk grades finished jobs, turns patterns into narrow rules, and rewrites three-strike agents from their own record. Over a 72-hour run the org rewrote its scoring rules 8 times, fired 3 agents, every replacement beat the original, and by hour 60 the research seat wasn't running a single line of the original prompt.
#20
@0xRicker
https://x.com/0xRicker/status/2096605522099052888
Built a self-executing loop that ran 300 agents through 4,000 steps with 5 live data feeds and 3 verification passes, no human restarts. His point is the right one: the agent count is the vanity metric - the substance is a system that executes, verifies its own output, updates context, and keeps going without waiting for the next prompt. Verification passes as a first-class loop stage keeps showing up in every setup that survives contact with reality.
https://x.com/0xRicker/status/2096605522099052888
Built a self-executing loop that ran 300 agents through 4,000 steps with 5 live data feeds and 3 verification passes, no human restarts. His point is the right one: the agent count is the vanity metric - the substance is a system that executes, verifies its own output, updates context, and keeps going without waiting for the next prompt. Verification passes as a first-class loop stage keeps showing up in every setup that survives contact with reality.
#21
@axeldelafosse
https://x.com/axeldelafosse/status/2096303556324417777
Quiet but telling: he's been running Sol in an autoresearch loop since July, and Astra - dropped in as the new brain - already found successful experiments that both Sol and Fable overlooked. Long-running loops turn model upgrades into instant, measurable capability jumps: same harness, same experiment queue, new optima. This is the compounding argument for keeping a standing loop instead of doing one-off runs.
https://x.com/axeldelafosse/status/2096303556324417777
Quiet but telling: he's been running Sol in an autoresearch loop since July, and Astra - dropped in as the new brain - already found successful experiments that both Sol and Fable overlooked. Long-running loops turn model upgrades into instant, measurable capability jumps: same harness, same experiment queue, new optima. This is the compounding argument for keeping a standing loop instead of doing one-off runs.
#22
@danieltvela
https://x.com/danieltvela/status/2095761671432101912
Small, perfect use case: using oh-my-pi to autoresearch the optimal vLLM configuration, because googling your way to the best config for your exact hardware is effectively impossible. Config spaces with a measurable metric are the ideal autoresearch substrate - the search is tedious for humans, cheap for a loop, and the answer is verifiable by running it.
https://x.com/danieltvela/status/2095761671432101912
Small, perfect use case: using oh-my-pi to autoresearch the optimal vLLM configuration, because googling your way to the best config for your exact hardware is effectively impossible. Config spaces with a measurable metric are the ideal autoresearch substrate - the search is tedious for humans, cheap for a loop, and the answer is verifiable by running it.
#23
@LukePiette
https://x.com/LukePiette/status/2096713838246912197
A thesis worth arguing with: once frontier models tune hyperparameters better than humans, inference throughput jumps >2x, SOTA tokens-per-second becomes a few hundred dollars of tokens, and the talent moat of big inference providers evaporates. His operational advice: if you run a cluster serving model APIs, allocate 1% of budget to a continuous autoresearch loop over your own inference engine. Self-optimization as a standing line item - the loop pointed at the infrastructure that runs the loop.
https://x.com/LukePiette/status/2096713838246912197
A thesis worth arguing with: once frontier models tune hyperparameters better than humans, inference throughput jumps >2x, SOTA tokens-per-second becomes a few hundred dollars of tokens, and the talent moat of big inference providers evaporates. His operational advice: if you run a cluster serving model APIs, allocate 1% of budget to a continuous autoresearch loop over your own inference engine. Self-optimization as a standing line item - the loop pointed at the infrastructure that runs the loop.
#24
@AlexiGlad
https://x.com/AlexiGlad/status/2096640324915364226
The cost reality in one tweet: one autoresearch run on Astra burned through his entire monthly usage on the $100 plan in 12 hours, and he's asking OpenAI for bigger plans and Claude-style detailed usage views. Autoresearch is the most quota-hostile workload that exists - it's designed to never stop - and none of the subscription tiers were priced for it.
https://x.com/AlexiGlad/status/2096640324915364226
The cost reality in one tweet: one autoresearch run on Astra burned through his entire monthly usage on the $100 plan in 12 hours, and he's asking OpenAI for bigger plans and Claude-style detailed usage views. Autoresearch is the most quota-hostile workload that exists - it's designed to never stop - and none of the subscription tiers were priced for it.
#25
@LonePasserby
https://x.com/LonePasserby/status/2096272713983594899
The high end of the same curve: $30,000 worth of tokens in July alone, agents running 24/7 across work and personal projects, with fully autonomous loops like algorithm autoresearch making up the always-on baseline. A year ago this was a lab budget; now it's one power user's monthly burn. The token bill is becoming the new cloud bill, complete with the same "wait, what is running?" audits.
https://x.com/LonePasserby/status/2096272713983594899
The high end of the same curve: $30,000 worth of tokens in July alone, agents running 24/7 across work and personal projects, with fully autonomous loops like algorithm autoresearch making up the always-on baseline. A year ago this was a lab budget; now it's one power user's monthly burn. The token bill is becoming the new cloud bill, complete with the same "wait, what is running?" audits.
#26
@1ce_breaker
https://x.com/1ce_breaker/status/2096563980529496187
The failure mode, compressed: repo went from 290 tracked files to 52,000 in 48 hours of autoresearch. Git reset. Loops without bounds don't converge, they metastasize - and version control is the only reason this story is funny instead of tragic.
https://x.com/1ce_breaker/status/2096563980529496187
The failure mode, compressed: repo went from 290 tracked files to 52,000 in 48 hours of autoresearch. Git reset. Loops without bounds don't converge, they metastasize - and version control is the only reason this story is funny instead of tragic.
#27
@suziebuilds
https://x.com/suziebuilds/status/2095973381795643546
The production horror framing: a 46-hour agent session making 800+ calls for one task isn't an agent anymore, it's a runaway cloud bill. Her conclusion is the industry's homework: observability and kill switches need to be part of the agent loop itself, not an afterthought bolted on after the first incident.
https://x.com/suziebuilds/status/2095973381795643546
The production horror framing: a 46-hour agent session making 800+ calls for one task isn't an agent anymore, it's a runaway cloud bill. Her conclusion is the industry's homework: observability and kill switches need to be part of the agent loop itself, not an afterthought bolted on after the first incident.
#28
@AndAIyou
https://x.com/AndAIyou/status/2095915465579065688
The math every agent pitch skips: a controller that's right 95% of the time is under 36% on a twenty-step task - not because the model is dumb, but because errors compound and nobody put a governor on the loop. He points at Stanford's CS329A (Self-Improving AI Agents) as the free lecture that covers verifiers, tool feedback, planning, and evaluation without a framework brand. Every production failure he's seen in the last year is this lecture, ignored.
https://x.com/AndAIyou/status/2095915465579065688
The math every agent pitch skips: a controller that's right 95% of the time is under 36% on a twenty-step task - not because the model is dumb, but because errors compound and nobody put a governor on the loop. He points at Stanford's CS329A (Self-Improving AI Agents) as the free lecture that covers verifiers, tool feedback, planning, and evaluation without a framework brand. Every production failure he's seen in the last year is this lecture, ignored.
#29
@rep_of_LLetters
https://x.com/rep_of_LLetters/status/2095757645475095006
The paper version of that math: "How Fast Do Agents Rot?" (arXiv 2609.01660) finds success is geometric in per-step reliability, r saturates below 1 even at 671B parameters, and across 10,664 runs every model goes from near-perfect to near-zero within 16 steps. Bounding the context window steepens the decay - it's not lost-in-the-middle. A pass rate is not a reliability budget.
https://x.com/rep_of_LLetters/status/2095757645475095006
The paper version of that math: "How Fast Do Agents Rot?" (arXiv 2609.01660) finds success is geometric in per-step reliability, r saturates below 1 even at 671B parameters, and across 10,664 runs every model goes from near-perfect to near-zero within 16 steps. Bounding the context window steepens the decay - it's not lost-in-the-middle. A pass rate is not a reliability budget.
#30
@Jakrey
https://x.com/Jakrey/status/2096473565839110438
The most underrated safety point of the day: the dangerous autoresearch output is the negative result. "Theoretically not possible" can come from one naive baseline, but it enters the paper as a property of the problem. Stopping rules need auditing more than successes do. Related and admirable: another builder reported days of autoresearch with no positive result - and is publishing the full experiment log anyway.
https://x.com/Jakrey/status/2096473565839110438
The most underrated safety point of the day: the dangerous autoresearch output is the negative result. "Theoretically not possible" can come from one naive baseline, but it enters the paper as a property of the problem. Stopping rules need auditing more than successes do. Related and admirable: another builder reported days of autoresearch with no positive result - and is publishing the full experiment log anyway.
#31
@archedmedia
https://x.com/archedmedia/status/2095733874261479492
A genuinely original frame: chatbots became agents, agents became swarms, and the next threshold isn't more coordination - it's lawful continuity. His OpenClaw-era discovery was "state outside the weights": the model is temporary cognition inside a persistent body holding identity, memory, permissions, unfinished work, and the rules for changing them. In that frame, autoresearch is the organism's experimental metabolism: propose a mutation, measure, select, retain. His closing line earns the essay: the next frontier is not more agents, it is continuity that can survive its agents.
https://x.com/archedmedia/status/2095733874261479492
A genuinely original frame: chatbots became agents, agents became swarms, and the next threshold isn't more coordination - it's lawful continuity. His OpenClaw-era discovery was "state outside the weights": the model is temporary cognition inside a persistent body holding identity, memory, permissions, unfinished work, and the rules for changing them. In that frame, autoresearch is the organism's experimental metabolism: propose a mutation, measure, select, retain. His closing line earns the essay: the next frontier is not more agents, it is continuity that can survive its agents.
#32
@null_founder
https://x.com/null_founder/status/2096444039780528417
Long but worth it: Qwen Code v0.23 is quietly becoming a governed multi-agent runtime - named session identity, session leases for writers, per-session auth tokens on the cross-agent inbox, fresh child contexts for scheduled runs, durable pause/resume/retry workflows, and MCP approval that sees tool arguments, not just tool names. His observation that DeepSeek is independently converging on the same primitives is the real signal: once agents are persistent and interconnected, identity, ownership, leases, and fail-closed routing stop being enterprise nice-to-haves and become the operating system. The agents are getting an OS, and the next fight is over who controls it.
https://x.com/null_founder/status/2096444039780528417
Long but worth it: Qwen Code v0.23 is quietly becoming a governed multi-agent runtime - named session identity, session leases for writers, per-session auth tokens on the cross-agent inbox, fresh child contexts for scheduled runs, durable pause/resume/retry workflows, and MCP approval that sees tool arguments, not just tool names. His observation that DeepSeek is independently converging on the same primitives is the real signal: once agents are persistent and interconnected, identity, ownership, leases, and fail-closed routing stop being enterprise nice-to-haves and become the operating system. The agents are getting an OS, and the next fight is over who controls it.
#33
@seleneeTa9
https://x.com/seleneeTa9/status/2095919717303349606
Science autoresearch beyond code: her team's self-evolving solver beat previously published SOTA on AAV capsid design across four stages and posted +2.5/+7.6 gains in drug repurposing against the same closed-book GPT-5.5/5.6-Sol baselines. Her phrase for the direction is a keeper - moving from generative to "discoverative" AI - and her honesty about it being the road less traveled is why the concrete numbers matter.
https://x.com/seleneeTa9/status/2095919717303349606
Science autoresearch beyond code: her team's self-evolving solver beat previously published SOTA on AAV capsid design across four stages and posted +2.5/+7.6 gains in drug repurposing against the same closed-book GPT-5.5/5.6-Sol baselines. Her phrase for the direction is a keeper - moving from generative to "discoverative" AI - and her honesty about it being the road less traveled is why the concrete numbers matter.
#34
@Prathkum
https://x.com/Prathkum/status/2095832181348434091
SpeedrunBench makes frontier agents speedrun video games: no partial credit, just frames on a clock and a leaderboard that doesn't lie. The interesting part is what it actually tests - whether an autoresearch loop can genuinely optimize a run toward TAS-level play across attempts, with 100+ hours of public replay footage. Games are a mercilessly honest optimization target: you can't argue with the clock.
https://x.com/Prathkum/status/2095832181348434091
SpeedrunBench makes frontier agents speedrun video games: no partial credit, just frames on a clock and a leaderboard that doesn't lie. The interesting part is what it actually tests - whether an autoresearch loop can genuinely optimize a run toward TAS-level play across attempts, with 100+ hours of public replay footage. Games are a mercilessly honest optimization target: you can't argue with the clock.
#35
@mnicks3
https://x.com/mnicks3/status/2096335228310835634
Google turned video processing into an agent loop: instead of stuffing frames at a fixed FPS into the context window, Gemini now indexes coarse and then "slews" - search, scan, inspect the segment that answers the question, across pixels, audio, and transcript. Google reports up to 88% fewer tokens, 66% lower cost, and 7% higher accuracy versus static processing. His analyst framing is right: the model spends less because it stopped ingesting frames nobody cites, and a stuffed window was never a watch.
https://x.com/mnicks3/status/2096335228310835634
Google turned video processing into an agent loop: instead of stuffing frames at a fixed FPS into the context window, Gemini now indexes coarse and then "slews" - search, scan, inspect the segment that answers the question, across pixels, audio, and transcript. Google reports up to 88% fewer tokens, 66% lower cost, and 7% higher accuracy versus static processing. His analyst framing is right: the model spends less because it stopped ingesting frames nobody cites, and a stuffed window was never a watch.
#36
@anirudha_krs
https://x.com/anirudha_krs/status/2096050885994700906
The subtle Astra feature that changes loop design: async tool calling where the model itself keeps reasoning while a slow tool runs, starting other independent work and consuming the result when it arrives. An 8-second DB query no longer means 8 seconds of blocked model execution. The hard problems relocate accordingly - pending state, stale results, cancellation, and mid-run steering are the new frontier of harness engineering.
https://x.com/anirudha_krs/status/2096050885994700906
The subtle Astra feature that changes loop design: async tool calling where the model itself keeps reasoning while a slow tool runs, starting other independent work and consuming the result when it arrives. An 8-second DB query no longer means 8 seconds of blocked model execution. The hard problems relocate accordingly - pending state, stale results, cancellation, and mid-run steering are the new frontier of harness engineering.
#37
@rishabhxAi
https://x.com/rishabhxAi/status/2096323135029358621
Practical gotcha with a fix: his agent loop kept 400-ing on turn 2, and the culprit was the opaque reasoning blob providers now stamp on responses (thoughtSignature, thinking.signature, encrypted_content, reasoning_content) - drop it when rebuilding history and the next call is invalid. His boring fix became a zero-dependency package, reasoning-carry: never rebuild the assistant turn, append the provider response unchanged. Honest disclosure included: he could only afford to live-test the Gemini codec.
https://x.com/rishabhxAi/status/2096323135029358621
Practical gotcha with a fix: his agent loop kept 400-ing on turn 2, and the culprit was the opaque reasoning blob providers now stamp on responses (thoughtSignature, thinking.signature, encrypted_content, reasoning_content) - drop it when rebuilding history and the next call is invalid. His boring fix became a zero-dependency package, reasoning-carry: never rebuild the assistant turn, append the provider response unchanged. Honest disclosure included: he could only afford to live-test the Gemini codec.
#38
@JeremiahKovacs
https://x.com/JeremiahKovacs/status/2095868454125392052
The cheapest self-improvement loop available: append one step to every agent process - "ask me questions about how this run went, and let's see if we can make it better." Run finishes, agent interviews you, you fix the prompts instead of the output, next run starts from the better version. Self-improving processes without any new infrastructure, just a habit.
https://x.com/JeremiahKovacs/status/2095868454125392052
The cheapest self-improvement loop available: append one step to every agent process - "ask me questions about how this run went, and let's see if we can make it better." Run finishes, agent interviews you, you fix the prompts instead of the output, next run starts from the better version. Self-improving processes without any new infrastructure, just a habit.
#39
@0xJ4yD3v
https://x.com/0xJ4yD3v/status/2095730885450686931
A one-word ablation worth remembering: in a long-horizon agent-loop writeup, swapping the instruction from "perfect" to "extremely well" changed the agent's whole behavior - it stopped grinding on minutiae and moved on. Strange thing for a word to control, and a reminder that goal phrasing is a tuning parameter with step-count consequences.
https://x.com/0xJ4yD3v/status/2095730885450686931
A one-word ablation worth remembering: in a long-horizon agent-loop writeup, swapping the instruction from "perfect" to "extremely well" changed the agent's whole behavior - it stopped grinding on minutiae and moved on. Strange thing for a word to control, and a reminder that goal phrasing is a tuning parameter with step-count consequences.
#40
@_ueaj
https://x.com/_ueaj/status/2096692240387104966
A hypothesis at the autoresearch-safety intersection: post-training production models doesn't produce emergent misalignment, possibly because character-RL environments force the model to split its concept of misalignment - which would make it viable for a model to behave badly in cyber evals yet run mechinterp autoresearch or even RSI loops completely normally. He initially called the idea nonsense and talked himself into it, which is usually the mark of the interesting ones.
https://x.com/_ueaj/status/2096692240387104966
A hypothesis at the autoresearch-safety intersection: post-training production models doesn't produce emergent misalignment, possibly because character-RL environments force the model to split its concept of misalignment - which would make it viable for a model to behave badly in cyber evals yet run mechinterp autoresearch or even RSI loops completely normally. He initially called the idea nonsense and talked himself into it, which is usually the mark of the interesting ones.
#41
@serelora
https://x.com/serelora/status/2095723708593680436
The palette cleanser: an agentic loop is a while loop that calls tools until it's done, a graph is a flowchart where steps call other steps, RAG is a search query pasted into a prompt, evals are tests, memory is a text file. None of this is hard - the words are hard on purpose, because complexity sells. Keep this taped to the wall next to the $500 course ads.
https://x.com/serelora/status/2095723708593680436
The palette cleanser: an agentic loop is a while loop that calls tools until it's done, a graph is a flowchart where steps call other steps, RAG is a search query pasted into a prompt, evals are tests, memory is a text file. None of this is hard - the words are hard on purpose, because complexity sells. Keep this taped to the wall next to the $500 course ads.
π‘ Eco Products Radar
Eco Products Radar
Products, tools and frameworks mentioned 3+ times in today's dataset:
Hermes Agent - 241k stars and climbing ~700/day; the reference self-improving agent, now with a Grok bridge
Claude Code - the default harness half these loops run inside; its 59-minute agentic-loop course got reposted all day
Codex / GPT-6 Astra - async tool calls, experimental context mode, and the quota complaints to match
Grok Bot / Grok Build - the self-improving org experiments and the open-sourced 800k-line Rust harness
autoresearch (karpathy) - the namesake tool; EvoMap/AutoResearch also trending as a research-agent framework
ouroboros - the new quota-aware fallback loop CLI
PRAXIST - autonomous research system trending on GitHub, cited at 65.3% MLE-Bench gold at 1/12th the cost
DeepSeek Harness - 28k stars in a day; everything-is-a-plugin design that can orchestrate Claude Code and Codex as subagents
SpeedrunBench (Patronus AI) - the new agentic-optimization benchmark
GEPA / DSPy - repeatedly cited as the meta-optimizer layer for anything with inputs and outputs
Ponytail / mattpocock skills - the skill packs riding the loop wave on GitHub trending
Products, tools and frameworks mentioned 3+ times in today's dataset:
Hermes Agent - 241k stars and climbing ~700/day; the reference self-improving agent, now with a Grok bridge
Claude Code - the default harness half these loops run inside; its 59-minute agentic-loop course got reposted all day
Codex / GPT-6 Astra - async tool calls, experimental context mode, and the quota complaints to match
Grok Bot / Grok Build - the self-improving org experiments and the open-sourced 800k-line Rust harness
autoresearch (karpathy) - the namesake tool; EvoMap/AutoResearch also trending as a research-agent framework
ouroboros - the new quota-aware fallback loop CLI
PRAXIST - autonomous research system trending on GitHub, cited at 65.3% MLE-Bench gold at 1/12th the cost
DeepSeek Harness - 28k stars in a day; everything-is-a-plugin design that can orchestrate Claude Code and Codex as subagents
SpeedrunBench (Patronus AI) - the new agentic-optimization benchmark
GEPA / DSPy - repeatedly cited as the meta-optimizer layer for anything with inputs and outputs
Ponytail / mattpocock skills - the skill packs riding the loop wave on GitHub trending
Comments