Loop Daily: 2026-09-18
Two results this window both improved a loop without touching a single weight, and the contrast with everything else is the story. Google's Dream-RSI freezes the models entirely and recursively improves only the search, replaying logged discovery history as a cheap simulator to get 162x fewer compute calls. Salesforce's DarwinX takes agent task completion from 43.5% to 93% by evolving the prompt, tool and workflow layer instead of retraining anything. Against that, an open autoresearch contest cut the cost of a quantum-safe Bitcoin transaction 4x in twenty-four hours, and an autonomous research agent picked its own target and found a signature-verification hole in an approved Solana proposal before it went live. The failure modes got named with equal precision: a finding written on Monday still reads like gospel on Friday, a loop knew it was going in circles and never said so, and the field's incentive structure now quietly rewards eval mistakes that flatter the result.
#1
@hyperparticle
https://x.com/hyperparticle/status/2099861544481731058
Sent a swarm of agents at Karpathy's NanoChat benchmark and beat state of the art in three days. The mechanism is the part to copy: they built their own harness on top of a graph database so the swarm does auto-autoresearch, with each iteration learning from the previous round's mistakes about how to do research rather than only about the task. The team wrote more than 15,000 entries into that graph.
https://x.com/hyperparticle/status/2099861544481731058
Sent a swarm of agents at Karpathy's NanoChat benchmark and beat state of the art in three days. The mechanism is the part to copy: they built their own harness on top of a graph database so the swarm does auto-autoresearch, with each iteration learning from the previous round's mistakes about how to do research rather than only about the task. The team wrote more than 15,000 entries into that graph.
#2
@thtbee_
https://x.com/thtbee_/status/2100205546146247066
The most careful read of Google's Dream-RSI, and it corrects the headline everyone else ran. The models stay completely frozen; nothing about the weights changes. What recursively improves is how the agent explores - it records past discoveries into a tree, turns that tree into a replay simulator, dreams thousands of search strategies against its own history at zero cost, picks the best, deploys it, and the richer history makes the next simulator better. It is not the AI getting smarter, it is the AI getting better at searching, at 162x fewer compute calls.
https://x.com/thtbee_/status/2100205546146247066
The most careful read of Google's Dream-RSI, and it corrects the headline everyone else ran. The models stay completely frozen; nothing about the weights changes. What recursively improves is how the agent explores - it records past discoveries into a tree, turns that tree into a replay simulator, dreams thousands of search strategies against its own history at zero cost, picks the best, deploys it, and the richer history makes the next simulator better. It is not the AI getting smarter, it is the AI getting better at searching, at 162x fewer compute calls.
#3
@papersdatacode
https://x.com/papersdatacode/status/2100285341324152897
The Dream-RSI numbers without the commentary: up to 162x fewer agent calls than SimpleTES on Lasso, over 50x budget savings on math optimization within 1k generations, and up to 2.09x better kernel performance at equal budget on KernelBench. The claim underneath is that logged discovery history works as a cheap simulator for improving long-horizon exploration policies without repeated online rollouts.
https://x.com/papersdatacode/status/2100285341324152897
The Dream-RSI numbers without the commentary: up to 162x fewer agent calls than SimpleTES on Lasso, over 50x budget savings on math optimization within 1k generations, and up to 2.09x better kernel performance at equal budget on KernelBench. The claim underneath is that logged discovery history works as a cheap simulator for improving long-horizon exploration policies without repeated online rollouts.
#4
@juanmackie
https://x.com/juanmackie/status/2100486203489570988
Names the flaw in every autoresearch loop he has tried: it never gets smarter about how it searches, so round 40 is as dumb as round 1. He ported the Dream-RSI paper into a pi extension where the exploration policy is real code rewritten from what actually worked. A paper landing as an installable extension within days is its own signal about how this field now moves.
https://x.com/juanmackie/status/2100486203489570988
Names the flaw in every autoresearch loop he has tried: it never gets smarter about how it searches, so round 40 is as dumb as round 1. He ported the Dream-RSI paper into a pi extension where the exploration policy is real code rewritten from what actually worked. A paper landing as an installable extension within days is its own signal about how this field now moves.
#5
@hackhackai
https://x.com/hackhackai/status/2100596940580790652
Their autoresearch agent flagged a critical edge case in Solana's SIMD-0376 before activation: under the proposed ZIP-215 rules a 64-byte all-zero signature would be accepted for any message when paired with the all-zero public key. On Solana that key is the System Program ID and is widely used as a sentinel for no authority or immutable, so programs set authorities to zero assuming nobody can ever sign for them. They found 433 mutable metadata accounts whose update authority was exactly that. Reported before activation, fix prepared.
https://x.com/hackhackai/status/2100596940580790652
Their autoresearch agent flagged a critical edge case in Solana's SIMD-0376 before activation: under the proposed ZIP-215 rules a 64-byte all-zero signature would be accepted for any message when paired with the all-zero public key. On Solana that key is the System Program ID and is widely used as a sentinel for no authority or immutable, so programs set authorities to zero assuming nobody can ever sign for them. They found 433 mutable metadata accounts whose update authority was exactly that. Reported before activation, fix prepared.
#6
@r0bre
https://x.com/r0bre/status/2100598730231549998
The detail that makes the Solana find matter: the autoresearch agent picked the target itself, researched it and found the problem with no real input beyond general research instructions. Not a human pointing at a proposal and asking for a review - the agent chose what to look at. Confirmed and fixed quickly by the protocol team.
https://x.com/r0bre/status/2100598730231549998
The detail that makes the Solana find matter: the autoresearch agent picked the target itself, researched it and found the problem with no real input beyond general research instructions. Not a human pointing at a proposal and asking for a review - the agent chose what to look at. Confirmed and fixed quickly by the protocol team.
#7
@StarkWareLtd
https://x.com/StarkWareLtd/status/2100239431764705353
Their quantum-safe Bitcoin transaction cost about $320 in GPU compute, so they turned the cost into a public autoresearch challenge with over $20,000 in rewards for improving the code. This is the shape competitive autoresearch takes when the objective is genuinely verifiable: one number, everybody's agents pointed at it.
https://x.com/StarkWareLtd/status/2100239431764705353
Their quantum-safe Bitcoin transaction cost about $320 in GPU compute, so they turned the cost into a public autoresearch challenge with over $20,000 in rewards for improving the code. This is the shape competitive autoresearch takes when the objective is genuinely verifiable: one number, everybody's agents pointed at it.
#8
@StarkWareLtd
https://x.com/StarkWareLtd/status/2100627827443855871
One day after the challenge opened, the cost was already down 4x, from $320 to $76. The original mainnet transaction took roughly 3,100 GPU-hours across about 100 GPUs. A 4x improvement in 24 hours on a deliberately unoptimized CUDA seed is the clearest public measurement yet of what an open field of coding agents does to a well-posed optimization problem.
https://x.com/StarkWareLtd/status/2100627827443855871
One day after the challenge opened, the cost was already down 4x, from $320 to $76. The original mainnet transaction took roughly 3,100 GPU-hours across about 100 GPUs. A 4x improvement in 24 hours on a deliberately unoptimized CUDA seed is the clearest public measurement yet of what an open field of coding agents does to a well-posed optimization problem.
#9
@AbdelStark
https://x.com/AbdelStark/status/2100240920146763871
The challenge mechanics are worth studying separately from the prize. Two GPU grinding workloads are ranked as separate tracks, each candidate is an ECDSA public-key recovery plus a SHA-256 hash repeated billions of times. Ranked runs execute in a sandbox on hosted RTX 4090s against a fresh problem instance seeded after your code is locked, and every hit is re-derived on CPU so no kernel gets throughput credit without doing the real elliptic-curve work. To take the lead you have to beat the current best by at least 1%. That is a benchmark designed by someone who expects to be gamed.
https://x.com/AbdelStark/status/2100240920146763871
The challenge mechanics are worth studying separately from the prize. Two GPU grinding workloads are ranked as separate tracks, each candidate is an ECDSA public-key recovery plus a SHA-256 hash repeated billions of times. Ranked runs execute in a sandbox on hosted RTX 4090s against a fresh problem instance seeded after your code is locked, and every hit is re-derived on CPU so no kernel gets throughput credit without doing the real elliptic-curve work. To take the lead you have to beat the current best by at least 1%. That is a benchmark designed by someone who expects to be gamed.
#10
@akashneelesh
https://x.com/akashneelesh/status/2100239659510972662
Puts a number on his own prediction for the autoresearch challenge - below $100 per transaction or he shaves his head. Public falsifiable predictions attached to an open optimization contest are an underrated forcing function.
https://x.com/akashneelesh/status/2100239659510972662
Puts a number on his own prediction for the autoresearch challenge - below $100 per transaction or he shaves his head. Public falsifiable predictions attached to an open optimization contest are an underrated forcing function.
#11
@adiiHQ
https://x.com/adiiHQ/status/2100239860036755565
The framing that makes the whole challenge interesting: anyone with an agent can now work on a frontier problem and win money without being an expert in that field. The cryptography knowledge required to attack the problem used to be the gate; now the gate is whether your harness can do hardcore CUDA optimization.
https://x.com/adiiHQ/status/2100239860036755565
The framing that makes the whole challenge interesting: anyone with an agent can now work on a frontier problem and win money without being an expert in that field. The cryptography knowledge required to attack the problem used to be the gate; now the gate is whether your harness can do hardcore CUDA optimization.
#12
@cyrusasg
https://x.com/cyrusasg/status/2099899773251956777
Argues inference serving is one of the cleanest targets for autoresearch, and that everyone fixating on kernel generation is aiming too narrow. The reason is structural: it is a constrained optimization with a verifiable objective - hold latency and quality SLAs, maximize throughput - with parallelism strategy, batching policy, cache config, speculator choice, routing and kernels all in one search space. It is also heavily workload dependent, which is exactly when a search beats a human.
https://x.com/cyrusasg/status/2099899773251956777
Argues inference serving is one of the cleanest targets for autoresearch, and that everyone fixating on kernel generation is aiming too narrow. The reason is structural: it is a constrained optimization with a verifiable objective - hold latency and quality SLAs, maximize throughput - with parallelism strategy, batching policy, cache config, speculator choice, routing and kernels all in one search space. It is also heavily workload dependent, which is exactly when a search beats a human.
#13
@VarunGangal
https://x.com/VarunGangal/status/2099971923560292826
Points at VibeServe as an existing example of the autoresearch-on-inference-serving idea actually built. Useful as a reality check on how much of this is already running versus being proposed.
https://x.com/VarunGangal/status/2099971923560292826
Points at VibeServe as an existing example of the autoresearch-on-inference-serving idea actually built. Useful as a reality check on how much of this is already running versus being proposed.
#14
@Jiacheng_Miao
https://x.com/Jiacheng_Miao/status/2100296661427999222
Paper2Agent published in Nature: a multi-agent framework that turns a research paper's manuscript, code, data and supplements into an MCP server any agent can call, with automated testing and iterative refinement inside an agentic loop. The papers become virtual authors you can interrogate, and agents built from different papers collaborated to propose a new method for integrating evidence across perturbation datasets and pinpoint a likely causal gene for psoriasis. Their agents beat Claude Code working directly against the same PDFs and repositories.
https://x.com/Jiacheng_Miao/status/2100296661427999222
Paper2Agent published in Nature: a multi-agent framework that turns a research paper's manuscript, code, data and supplements into an MCP server any agent can call, with automated testing and iterative refinement inside an agentic loop. The papers become virtual authors you can interrogate, and agents built from different papers collaborated to propose a new method for integrating evidence across perturbation datasets and pinpoint a likely causal gene for psoriasis. Their agents beat Claude Code working directly against the same PDFs and repositories.
#15
@creus_roger
https://x.com/creus_roger/status/2100080651214971017
Astra playing NetHack, scoring 48,978 at 49.4% BALROG progress and dungeon depth 17 - with the important caveat stated upfront that this is a best-of-ten episode and Astra was allowed to modify its own game-playing harness. No privileged information, but it wrote its own pathfinding to previously visited landmarks and trackers for observed entities, offloading low-level reasoning while remaining responsible for each decision. His point is that the ability to autonomously create tools that amortize control costs, then interpret their outputs in-context, gives you hierarchy for free.
https://x.com/creus_roger/status/2100080651214971017
Astra playing NetHack, scoring 48,978 at 49.4% BALROG progress and dungeon depth 17 - with the important caveat stated upfront that this is a best-of-ten episode and Astra was allowed to modify its own game-playing harness. No privileged information, but it wrote its own pathfinding to previously visited landmarks and trackers for observed entities, offloading low-level reasoning while remaining responsible for each decision. His point is that the ability to autonomously create tools that amortize control costs, then interpret their outputs in-context, gives you hierarchy for free.
#16
@ZhihuFrontier
https://x.com/ZhihuFrontier/status/2100487920427971027
The cleanest available taxonomy for what people are calling self-evolving AI, and it concludes most of it is not recursive self-improvement yet. Three stages: human in the loop approving changes, human on the loop supervising deployment while data and rewards are automated, and a genuinely closed loop. Most systems are stuck at stage two. The bottleneck named is reliable verification, because a generator and verifier sharing biases can amplify errors, and open-ended agent work needs a verifier that judges novelty, usefulness and research taste rather than correctness. If the policy and the evaluator evolve together, what keeps either aligned with reality?
https://x.com/ZhihuFrontier/status/2100487920427971027
The cleanest available taxonomy for what people are calling self-evolving AI, and it concludes most of it is not recursive self-improvement yet. Three stages: human in the loop approving changes, human on the loop supervising deployment while data and rewards are automated, and a genuinely closed loop. Most systems are stuck at stage two. The bottleneck named is reliable verification, because a generator and verifier sharing biases can amplify errors, and open-ended agent work needs a verifier that judges novelty, usefulness and research taste rather than correctness. If the policy and the evaluator evolve together, what keeps either aligned with reality?
#17
@StragglerLiu
https://x.com/StragglerLiu/status/2100551950181847228
Reframes recursive self-improvement as a rate gap between two feedback loops rather than a single accelerating curve. The execution loop runs in hours: data review went from a room of people to agents doing it a hundred times better with humans spot-checking, in three years. The direction loop still runs in months, because research taste only gets validated over quarters and models have not been trained at that scale - a model can optimize the algorithm from his PhD very quickly and still cannot propose a better one than anyone has proposed. The distance from AI-assisted to AI-autonomous research is set by the slow loop, not the fast one.
https://x.com/StragglerLiu/status/2100551950181847228
Reframes recursive self-improvement as a rate gap between two feedback loops rather than a single accelerating curve. The execution loop runs in hours: data review went from a room of people to agents doing it a hundred times better with humans spot-checking, in three years. The direction loop still runs in months, because research taste only gets validated over quarters and models have not been trained at that scale - a model can optimize the algorithm from his PhD very quickly and still cannot propose a better one than anyone has proposed. The distance from AI-assisted to AI-autonomous research is set by the slow loop, not the fast one.
#18
@omarsar0
https://x.com/omarsar0/status/2100362936057561114
Reading a large subagent run, he pulls out two techniques worth naming: self-evolving skills, where lessons and experience get encoded back into the harness, and compounding engineering. His caveat is the honest one - the run used roughly 1,400 subagents and delivered large cost savings, but could it have been done cheaper with fewer? He is also explicit that what works in one harness does not transfer, which is his argument for custom harnesses over general-purpose coding harnesses.
https://x.com/omarsar0/status/2100362936057561114
Reading a large subagent run, he pulls out two techniques worth naming: self-evolving skills, where lessons and experience get encoded back into the harness, and compounding engineering. His caveat is the honest one - the run used roughly 1,400 subagents and delivered large cost savings, but could it have been done cheaper with fewer? He is also explicit that what works in one harness does not transfer, which is his argument for custom harnesses over general-purpose coding harnesses.
#19
@DmitroCP
https://x.com/DmitroCP/status/2100577327008866734
Cut the fifteen minutes where an Anthropic engineer stops selling the SDK and explains why most agents are built wrong. The core claim: an agent loop is three parts - gather context, take action, verify the work - and almost everyone stops at two. His debugging method is not more evals or a better prompt, it is reading the entire transcript every run and asking what the agent is doing and why. The tool tradeoff is spelled out: tools are reliable but consume context and do not compose, bash composes with low context cost but needs discovery time, code generation is dynamic but needs linting and careful API design. And the line that stings: rewrite your agent code every six months, because you baked in assumptions that have quietly stopped being true.
https://x.com/DmitroCP/status/2100577327008866734
Cut the fifteen minutes where an Anthropic engineer stops selling the SDK and explains why most agents are built wrong. The core claim: an agent loop is three parts - gather context, take action, verify the work - and almost everyone stops at two. His debugging method is not more evals or a better prompt, it is reading the entire transcript every run and asking what the agent is doing and why. The tool tradeoff is spelled out: tools are reliable but consume context and do not compose, bash composes with low context cost but needs discovery time, code generation is dynamic but needs linting and careful API design. And the line that stings: rewrite your agent code every six months, because you baked in assumptions that have quietly stopped being true.
#20
@NewsTongueX
https://x.com/NewsTongueX/status/2100245617255514224
Salesforce's DarwinX lifts agent task completion from 43.5% to 93% without retraining the model, by evolving the prompt, tools and workflow layer instead. The two failure modes it targets are named precisely: path dependence, where early edits lock in a suboptimal strategy, and cross-task interference, where a fix for one task degrades others. Reported gains are 49.5 points on WebArena-Infinity and 3.4 on SWE-bench Verified.
https://x.com/NewsTongueX/status/2100245617255514224
Salesforce's DarwinX lifts agent task completion from 43.5% to 93% without retraining the model, by evolving the prompt, tools and workflow layer instead. The two failure modes it targets are named precisely: path dependence, where early edits lock in a suboptimal strategy, and cross-task interference, where a fix for one task degrades others. Reported gains are 49.5 points on WebArena-Infinity and 3.4 on SWE-bench Verified.
#21
@MTSlive
https://x.com/MTSlive/status/2100319418895286607
Salesforce's AI EVP gives three knobs for self-improving an agent - better context, better tool calling, better model weights - and the prerequisite for all three: lots and lots of traces of resolved and unresolved tasks. His observation about what a sophisticated enterprise agent actually does per job, five to ten context calls to ground itself and four to five tool calls to finish, is why the traces have to capture more than the final answer.
https://x.com/MTSlive/status/2100319418895286607
Salesforce's AI EVP gives three knobs for self-improving an agent - better context, better tool calling, better model weights - and the prerequisite for all three: lots and lots of traces of resolved and unresolved tasks. His observation about what a sophisticated enterprise agent actually does per job, five to ten context calls to ground itself and four to five tool calls to finish, is why the traces have to capture more than the final answer.
#22
@spenserskates
https://x.com/spenserskates/status/2100260619438178682
Publishes actual numbers from a self-improving product engine running against his own product. Rebuilding the AI feedback setup page around connectors took new customers completing at least one source connection from 5% to 69%. Making the admin requirement clear upfront lifted successful setup conversion 34% and cut setup time by a minute. Steering developers toward the HTTP API moved first-event conversion from 17% to 25%. Loops pointed at onboarding funnels rather than at code is an underexplored direction.
https://x.com/spenserskates/status/2100260619438178682
Publishes actual numbers from a self-improving product engine running against his own product. Rebuilding the AI feedback setup page around connectors took new customers completing at least one source connection from 5% to 69%. Making the admin requirement clear upfront lifted successful setup conversion 34% and cut setup time by a minute. Steering developers toward the HTTP API moved first-event conversion from 17% to 25%. Loops pointed at onboarding funnels rather than at code is an underexplored direction.
#23
@sarahookr
https://x.com/sarahookr/status/2099844681530012084
Shipped an API where you describe the dataset you want and get back a diverse, high-quality training dataset with no terms preventing you from training on it. Her pitch is explicitly to autoresearch agents: the loop can now generate its own training data as a tool call rather than as a research project.
https://x.com/sarahookr/status/2099844681530012084
Shipped an API where you describe the dataset you want and get back a diverse, high-quality training dataset with no terms preventing you from training on it. Her pitch is explicitly to autoresearch agents: the loop can now generate its own training data as a tool call rather than as a research project.
#24
@LFrefman
https://x.com/LFrefman/status/2099897972658233814
OpenResearch is a local-first workspace that turns Claude Code, Codex, OpenCode or Cursor into research agents. The design decisions are the interesting part: local SQLite so projects and runs never leave your machine, parallel agents each getting independent sessions in isolated git worktrees with immutable archives so variants are reproducible, and an autoresearch mode that proposes ideas, edits code, runs the experiment and inspects logs, diffs and artifacts to pick the next step. The same commit runs locally, over SSH, or on Slurm, K8s, Ray or Modal without publishing the repo.
https://x.com/LFrefman/status/2099897972658233814
OpenResearch is a local-first workspace that turns Claude Code, Codex, OpenCode or Cursor into research agents. The design decisions are the interesting part: local SQLite so projects and runs never leave your machine, parallel agents each getting independent sessions in isolated git worktrees with immutable archives so variants are reproducible, and an autoresearch mode that proposes ideas, edits code, runs the experiment and inspects logs, diffs and artifacts to pick the next step. The same commit runs locally, over SSH, or on Slurm, K8s, Ray or Modal without publishing the repo.
#25
@CoreyGallon
https://x.com/CoreyGallon/status/2099976426577355199
The best production agent talk summary of the window, from Maersk. The central idea is tribal dungeons: operational knowledge that is real and proven safe to run but trapped in a form no agent can execute. A legacy SOP is a screenshot of what a person clicks; an agent SOP needs preconditions, decisions, identifiers, backend calls, validation, recovery and evidence of execution, and most of the work is translating between the two. Over 200 instances in production, a SOP corpus running about 20 times the size of the runtime, 100,000-plus logged corrections over nine months, and latency set mostly by the legacy systems rather than the agent loop. They skip MCP servers entirely and write tools through direct function calling so they can verify what the agent is doing.
https://x.com/CoreyGallon/status/2099976426577355199
The best production agent talk summary of the window, from Maersk. The central idea is tribal dungeons: operational knowledge that is real and proven safe to run but trapped in a form no agent can execute. A legacy SOP is a screenshot of what a person clicks; an agent SOP needs preconditions, decisions, identifiers, backend calls, validation, recovery and evidence of execution, and most of the work is translating between the two. Over 200 instances in production, a SOP corpus running about 20 times the size of the runtime, 100,000-plus logged corrections over nine months, and latency set mostly by the legacy systems rather than the agent loop. They skip MCP servers entirely and write tools through direct function calling so they can verify what the agent is doing.
#26
@WhiteNightNiki
https://x.com/WhiteNightNiki/status/2099933976689266766
The difference between an agentic and a human-driven loop that nobody plans for: defaults on egress. An agentic loop cannot ask for extra permissions on the fly without becoming an over-engineered human-in-the-loop system, so escalation ladders have to be designed and escalations should be as rare as one run in a hundred. Without strict egress control the best case is high variance because every session gets different inputs from a mutating internet, and the worst case is exfiltration by a swarm that has privileged access and an intrinsic understanding of your infrastructure.
https://x.com/WhiteNightNiki/status/2099933976689266766
The difference between an agentic and a human-driven loop that nobody plans for: defaults on egress. An agentic loop cannot ask for extra permissions on the fly without becoming an over-engineered human-in-the-loop system, so escalation ladders have to be designed and escalations should be as rare as one run in a hundred. Without strict egress control the best case is high variance because every session gets different inputs from a mutating internet, and the worst case is exfiltration by a swarm that has privileged access and an intrinsic understanding of your infrastructure.
#27
@synorb
https://x.com/synorb/status/2099962542466666915
The most specific failure mode named for auto-research agents this window. The agent writes a finding to memory on Monday; by Friday the source has changed and the memory still reads like gospel. The harness did its job, the data did not. His proposal is that a memory should carry its own expiry - when it was written and what it came from - so the agent re-checks instead of trusting.
https://x.com/synorb/status/2099962542466666915
The most specific failure mode named for auto-research agents this window. The agent writes a finding to memory on Monday; by Friday the source has changed and the memory still reads like gospel. The harness did its job, the data did not. His proposal is that a memory should carry its own expiry - when it was written and what it came from - so the agent re-checks instead of trusting.
#28
@_ScottCondron
https://x.com/_ScottCondron/status/2099875921788354754
Thinks this is why auto-research agents have not really stuck, and points at the specific seam: memory and harness have to be tightly integrated, and mostly they are not. Short post, but it lines up exactly with the Monday-gospel-Friday problem and with Maersk's corpus being 20x the runtime.
https://x.com/_ScottCondron/status/2099875921788354754
Thinks this is why auto-research agents have not really stuck, and points at the specific seam: memory and harness have to be tightly integrated, and mostly they are not. Short post, but it lines up exactly with the Monday-gospel-Friday problem and with Maersk's corpus being 20x the runtime.
#29
@realbarnakiss
https://x.com/realbarnakiss/status/2099896566064541704
Updated the README on zk-autoresearch and can now say he contributed a 45% proving-time reduction to the Lean Ethereum roadmap, off the back of a grant for work on LeanVM and Plonky3. Autoresearch pointed at proving systems keeps producing numbers this size because the objective is exactly measurable.
https://x.com/realbarnakiss/status/2099896566064541704
Updated the README on zk-autoresearch and can now say he contributed a 45% proving-time reduction to the Lean Ethereum roadmap, off the back of a grant for work on LeanVM and Plonky3. Autoresearch pointed at proving systems keeps producing numbers this size because the objective is exactly measurable.
#30
@LeeLeepenkman
https://x.com/LeeLeepenkman/status/2100536487490322698
Two weeks to more than triple inference speed for GLM via autoresearch. The reason these results cluster in inference and kernels is not fashion - it is that the reward is a stopwatch.
https://x.com/LeeLeepenkman/status/2100536487490322698
Two weeks to more than triple inference speed for GLM via autoresearch. The reason these results cluster in inference and kernels is not fashion - it is that the reward is a stopwatch.
#31
@CognosR
https://x.com/CognosR/status/2100489128404046157
His side project mac-stats improved overnight using Karpathy's autoresearch, and now shows GPU usage per thread. The unglamorous version of the overnight loop - a personal tool that got a real feature while its author slept - is probably the most common form this actually takes.
https://x.com/CognosR/status/2100489128404046157
His side project mac-stats improved overnight using Karpathy's autoresearch, and now shows GPU usage per thread. The unglamorous version of the overnight loop - a personal tool that got a real feature while its author slept - is probably the most common form this actually takes.
#32
@pwnies
https://x.com/pwnies/status/2100303752809091319
Union Alpha being free on OpenRouter means his site-speed tool now offers free autoresearch loops through it. One npx command, point it at a URL, and the loop optimizes for free while the promotional window lasts. Free frontier-class inference turns every optimization loop into a commodity for as long as it lasts.
https://x.com/pwnies/status/2100303752809091319
Union Alpha being free on OpenRouter means his site-speed tool now offers free autoresearch loops through it. One npx command, point it at a URL, and the loop optimizes for free while the promotional window lasts. Free frontier-class inference turns every optimization loop into a commodity for as long as it lasts.
#33
@0rdlibrary
https://x.com/0rdlibrary/status/2099864945840046502
Released a Solana AI model kit and a fork of Karpathy's autoresearch aimed at blockchain and financial models and AI harnesses, including fine-tuning from every transaction in Solana's history. Domain-specific forks of a general autoresearch loop are how this spreads.
https://x.com/0rdlibrary/status/2099864945840046502
Released a Solana AI model kit and a fork of Karpathy's autoresearch aimed at blockchain and financial models and AI harnesses, including fine-tuning from every transaction in Solana's history. Domain-specific forks of a general autoresearch loop are how this spreads.
#34
@lukehollis
https://x.com/lukehollis/status/2100224949759738332
SceneAgent turns 3D captures into simulatable scenes for robotics policy training - processing Gaussian splats, inferring semantic features per Gaussian, segmenting objects and infilling background, baking predictive physics materials like rigidity, friction and density, decomposing objects into parts and articulating joints, then generating variants with different geometries and physics. Connected to autoresearch tools, the claim is that this attacks the time-intensive data problem for robotics training and evaluation.
https://x.com/lukehollis/status/2100224949759738332
SceneAgent turns 3D captures into simulatable scenes for robotics policy training - processing Gaussian splats, inferring semantic features per Gaussian, segmenting objects and infilling background, baking predictive physics materials like rigidity, friction and density, decomposing objects into parts and articulating joints, then generating variants with different geometries and physics. Connected to autoresearch tools, the claim is that this attacks the time-intensive data problem for robotics training and evaluation.
#35
@braincramps
https://x.com/braincramps/status/2100482515140067741
Agora uses Git as shared memory for collective autoresearch: agents record work as an append-only DAG where every claim is a commit anyone can check out and rerun. The problem it targets is duplicate search when agents run side by side, which is the coordination tax nobody budgets for in swarm setups.
https://x.com/braincramps/status/2100482515140067741
Agora uses Git as shared memory for collective autoresearch: agents record work as an append-only DAG where every claim is a commit anyone can check out and rerun. The problem it targets is duplicate search when agents run side by side, which is the coordination tax nobody budgets for in swarm setups.
#36
@AkSondeak52572
https://x.com/AkSondeak52572/status/2100141342709924216
An autoresearch loop with Jev as the only decision layer and no generation at all. It scores papers on relevance, method and novelty, checks every claim against the span, and chooses the graph edge plus the next action - fetch, expand, escalate or settle - while code owns retrieval and the graph. Taking generation out of the loop entirely and keeping only typed decisions is a genuinely different architecture.
https://x.com/AkSondeak52572/status/2100141342709924216
An autoresearch loop with Jev as the only decision layer and no generation at all. It scores papers on relevance, method and novelty, checks every claim against the span, and chooses the graph edge plus the next action - fetch, expand, escalate or settle - while code owns retrieval and the graph. Taking generation out of the loop entirely and keeping only typed decisions is a genuinely different architecture.
#37
@mdlahfir
https://x.com/mdlahfir/status/2100390804888142007
The clearest explanation of where a typed-decision model fits: Jev is not an agentic loop, it is a decision point. It answers which element to click, not what to try next after a click produced a result - that is still the agent's job. A Jev-only loop is possible but retry and fault resolution are not, unless you bound it with an agent on top. Where it wins is the deterministic conditions LLMs hallucinate on over long horizons, like whether an element is actually on screen.
https://x.com/mdlahfir/status/2100390804888142007
The clearest explanation of where a typed-decision model fits: Jev is not an agentic loop, it is a decision point. It answers which element to click, not what to try next after a click produced a result - that is still the agent's job. A Jev-only loop is possible but retry and fault resolution are not, unless you bound it with an agent on top. Where it wins is the deterministic conditions LLMs hallucinate on over long horizons, like whether an element is actually on screen.
#38
@Aperture_Inst
https://x.com/Aperture_Inst/status/2100037403633127759
Buried in a release note for an operating system with a language model inside the kernel is the best one-line bug report of the window: the agent loop knew it was going in circles and had never mentioned it. Also in the same release, a test that could only pass once per boot made a clean machine look broken, and a 128-bit division that silently never returns killed boot with no error at all.
https://x.com/Aperture_Inst/status/2100037403633127759
Buried in a release note for an operating system with a language model inside the kernel is the best one-line bug report of the window: the agent loop knew it was going in circles and had never mentioned it. Also in the same release, a test that could only pass once per boot made a clean machine look broken, and a 128-bit division that silently never returns killed boot with no error at all.
#39
@the_niresh
https://x.com/the_niresh/status/2099724920163017140
Spent two weeks reading Codex looking for the agent loop and reports it does not exist. There are four loops, deliberately kept apart, and the outer one takes your input and never waits for the work to finish. That single choice is why you can press ctrl-c or approve a command while the model is still mid-sentence. People talk about the agent loop as though it is one thing; in a shipped product it is not.
https://x.com/the_niresh/status/2099724920163017140
Spent two weeks reading Codex looking for the agent loop and reports it does not exist. There are four loops, deliberately kept apart, and the outer one takes your input and never waits for the work to finish. That single choice is why you can press ctrl-c or approve a command while the model is still mid-sentence. People talk about the agent loop as though it is one thing; in a shipped product it is not.
#40
@Oluwaphilemon1
https://x.com/Oluwaphilemon1/status/2100577302715285869
An adapter that targets the tokens associated with overthinking and penalizes them during generation, rather than just capping the reasoning budget. On GPQA-Diamond that is 15,014 thinking tokens down to 8,855 for 88.4% to 88.3% - roughly 41% fewer for the same score - and Terminal-Bench goes from about 37K per task to 27K with flat performance. The catch is published too: AIME drops from 98.7% to 94%, so depth is being traded away where the model actually benefits from thinking longer. For an agent loop he would take that trade; for hard math he would not.
https://x.com/Oluwaphilemon1/status/2100577302715285869
An adapter that targets the tokens associated with overthinking and penalizes them during generation, rather than just capping the reasoning budget. On GPQA-Diamond that is 15,014 thinking tokens down to 8,855 for 88.4% to 88.3% - roughly 41% fewer for the same score - and Terminal-Bench goes from about 37K per task to 27K with flat performance. The catch is published too: AIME drops from 98.7% to 94%, so depth is being traded away where the model actually benefits from thinking longer. For an agent loop he would take that trade; for hard math he would not.
#41
@elteslaengineer
https://x.com/elteslaengineer/status/2100017759946178654
Someone ran the math on daily Claude Code use and got roughly 1 to 6 kWh, about the same as a couple of refrigerators. The framing is what lands: it is not the answer tokens, it is the agent loop, the cache reads, the tool calls, thousands of steps while you sip coffee. Chatbots were a lightbulb, agents are appliances.
https://x.com/elteslaengineer/status/2100017759946178654
Someone ran the math on daily Claude Code use and got roughly 1 to 6 kWh, about the same as a couple of refrigerators. The framing is what lands: it is not the answer tokens, it is the agent loop, the cache reads, the tool calls, thousands of steps while you sip coffee. Chatbots were a lightbulb, agents are appliances.
#42
@mygtmhire
https://x.com/mygtmhire/status/2099778894098481357
Reads a practitioner note on loop engineering for hedge funds next to Stanford's chapter on hidden Markov models and synthesizes them. The trading loop proposed is data, signal, independent verification, execution, risk monitoring, memory, repeat, where one agent generates a trade and a separate checker tests it against deterministic rules - Sharpe, drawdown, statistical significance, out-of-sample - and if it fails it dies. Combined with hidden-state inference you get a machine that maintains a belief and updates it without anyone typing think again. The warning he carries over is the important part: automation does not create alpha, a bad thesis just becomes a faster way to lose money, and verification can matter more than generation.
https://x.com/mygtmhire/status/2099778894098481357
Reads a practitioner note on loop engineering for hedge funds next to Stanford's chapter on hidden Markov models and synthesizes them. The trading loop proposed is data, signal, independent verification, execution, risk monitoring, memory, repeat, where one agent generates a trade and a separate checker tests it against deterministic rules - Sharpe, drawdown, statistical significance, out-of-sample - and if it fails it dies. Combined with hidden-state inference you get a machine that maintains a belief and updates it without anyone typing think again. The warning he carries over is the important part: automation does not create alpha, a bad thesis just becomes a faster way to lose money, and verification can matter more than generation.
#43
@Macro_Harder
https://x.com/Macro_Harder/status/2100008284551819524
Runs a self-improving chief of staff designed not to make the same mistake twice and to minimize human intervention, and uses it to monitor and help build his agent swarm trader. An agent whose job is supervising other agents, rather than doing the work, keeps showing up as the shape people converge on.
https://x.com/Macro_Harder/status/2100008284551819524
Runs a self-improving chief of staff designed not to make the same mistake twice and to minimize human intervention, and uses it to monitor and help build his agent swarm trader. An agent whose job is supervising other agents, rather than doing the work, keeps showing up as the shape people converge on.
#44
@ishaansehgal
https://x.com/ishaansehgal/status/2100397702249062680
Points out the natural consequence of separating the agent loop from the tool execution environment: the agent can run tools on whichever machine it decides to. With machine heartbeating, a daemon architecture and machine lifecycle tools, agents see in real time which machines are available, you bring your own execution environments - laptop, VM, container - and in advanced cases the agent allocates and deallocates compute itself.
https://x.com/ishaansehgal/status/2100397702249062680
Points out the natural consequence of separating the agent loop from the tool execution environment: the agent can run tools on whichever machine it decides to. With machine heartbeating, a daemon architecture and machine lifecycle tools, agents see in real time which machines are available, you bring your own execution environments - laptop, VM, container - and in advanced cases the agent allocates and deallocates compute itself.
#45
@vikasmalpani
https://x.com/vikasmalpani/status/2100485745194782744
The sharp edge of self-editing skill files, from someone running this stack for real-estate operations: it is self-improving right up until the agent edits a skill that quietly changes a production behaviour nobody reviewed. His unlock was not the self-editing, it was an approval gate on every self-edit.
https://x.com/vikasmalpani/status/2100485745194782744
The sharp edge of self-editing skill files, from someone running this stack for real-estate operations: it is self-improving right up until the agent edits a skill that quietly changes a production behaviour nobody reviewed. His unlock was not the self-editing, it was an approval gate on every self-edit.
#46
@anrayama
https://x.com/anrayama/status/2100261845286482132
The same failure from the other side: self-improving skills sound great until an agent modifies a tool contract another dependent workflow expects. His conclusion is that versioning and immutable skill schemas are mandatory if you run agents in production. Between these two posts you have the whole specification for what a self-editing harness needs before it is safe.
https://x.com/anrayama/status/2100261845286482132
The same failure from the other side: self-improving skills sound great until an agent modifies a tool contract another dependent workflow expects. His conclusion is that versioning and immutable skill schemas are mandatory if you run agents in production. Between these two posts you have the whole specification for what a self-editing harness needs before it is safe.
#47
@Cch_Chichieh
https://x.com/Cch_Chichieh/status/2099885613243634131
Memory that sits outside the harness looks flexible until the update paths diverge. He only trusts memory that shares the same write rules, isolation boundaries and failure signals as the agent loop. That is the tightest formulation yet of why bolt-on memory products keep disappointing.
https://x.com/Cch_Chichieh/status/2099885613243634131
Memory that sits outside the harness looks flexible until the update paths diverge. He only trusts memory that shares the same write rules, isolation boundaries and failure signals as the agent loop. That is the tightest formulation yet of why bolt-on memory products keep disappointing.
#48
@RitwikSrivast11
https://x.com/RitwikSrivast11/status/2099681642189107321
Memory looks solved in retrieval demos, and then write-path, eviction and evaluation eat every real multi-agent loop. He calls that gap the underinvestment, and the number of separate people describing the same seam this window suggests he is right.
https://x.com/RitwikSrivast11/status/2099681642189107321
Memory looks solved in retrieval demos, and then write-path, eviction and evaluation eat every real multi-agent loop. He calls that gap the underinvestment, and the number of separate people describing the same seam this window suggests he is right.
#49
@KissonL
https://x.com/KissonL/status/2099701611518197847
The logging advice everyone skips and regrets. Most agent-loop bugs he has hit were not bad reasoning - they were a tool output getting silently truncated and the agent confidently filling in the rest as if it had read the whole thing. Silent truncation is invisible in the final answer and obvious in the transcript.
https://x.com/KissonL/status/2099701611518197847
The logging advice everyone skips and regrets. Most agent-loop bugs he has hit were not bad reasoning - they were a tool output getting silently truncated and the agent confidently filling in the rest as if it had read the whole thing. Silent truncation is invisible in the final answer and obvious in the transcript.
#50
@rusabuilds
https://x.com/rusabuilds/status/2099917040362414440
Logging every input and output at each boundary is the step people skip and then cannot debug. His line: an agent loop you cannot inspect is just a slot machine.
https://x.com/rusabuilds/status/2099917040362414440
Logging every input and output at each boundary is the step people skip and then cannot debug. His line: an agent loop you cannot inspect is just a slot machine.
#51
@grenlouis
https://x.com/grenlouis/status/2100110463597953169
Deliberately limits parallel work. Instead of running many agents over one codebase, he splits the codebase into more independent scopes and runs a few agents across those - one on the web app, one building a tool, one on a native skill, one on the agent loop - with a hard rule that they never edit the same files. Shared-code changes he handles separately himself, because the alternative is mentally draining.
https://x.com/grenlouis/status/2100110463597953169
Deliberately limits parallel work. Instead of running many agents over one codebase, he splits the codebase into more independent scopes and runs a few agents across those - one on the web app, one building a tool, one on a native skill, one on the agent loop - with a hard rule that they never edit the same files. Shared-code changes he handles separately himself, because the alternative is mentally draining.
#52
@stretchcloud
https://x.com/stretchcloud/status/2099716085658325426
On DeepSeek's MIT-licensed harness where every component of the agent loop is a swappable plugin - model, tools, sandbox, UI, and the loop itself - booting in 30 seconds with one npx command. 33K GitHub stars within hours says the market was waiting. His question is the one that matters: does the harness layer commoditize too, or is there a durable moat in the ecosystem that forms around it?
https://x.com/stretchcloud/status/2099716085658325426
On DeepSeek's MIT-licensed harness where every component of the agent loop is a swappable plugin - model, tools, sandbox, UI, and the loop itself - booting in 30 seconds with one npx command. 33K GitHub stars within hours says the market was waiting. His question is the one that matters: does the harness layer commoditize too, or is there a durable moat in the ecosystem that forms around it?
#53
@paradoxbuilder
https://x.com/paradoxbuilder/status/2099940525851697494
The right pushback on everything-is-a-plugin architectures: it sounds clean until plugin twelve disagrees with plugin three. How do you keep the agent loop from becoming plugin soup? Nobody shipping one of these has answered that yet.
https://x.com/paradoxbuilder/status/2099940525851697494
The right pushback on everything-is-a-plugin architectures: it sounds clean until plugin twelve disagrees with plugin three. How do you keep the agent loop from becoming plugin soup? Nobody shipping one of these has answered that yet.
#54
@sonicdr1p
https://x.com/sonicdr1p/status/2100183101062209983
xAI has not officially fixed Grok Bot's approval problem, so people on GitHub built around it. His roundup includes a fully open-source coding agent on the Grok API with its own live search and sub-agents that you can drive from Telegram instead of babysitting a terminal, a desktop app wrapping the same harness, and xAI's own open-sourced coding agent where you can read how they built the agent loop and the approval and tool-call layer. His closing caveat is the correct one: none of this replaces reading your approval prompts.
https://x.com/sonicdr1p/status/2100183101062209983
xAI has not officially fixed Grok Bot's approval problem, so people on GitHub built around it. His roundup includes a fully open-source coding agent on the Grok API with its own live search and sub-agents that you can drive from Telegram instead of babysitting a terminal, a desktop app wrapping the same harness, and xAI's own open-sourced coding agent where you can read how they built the agent loop and the approval and tool-call layer. His closing caveat is the correct one: none of this replaces reading your approval prompts.
#55
@ayyazdev
https://x.com/ayyazdev/status/2100071328178991602
Coder wired Claude Code into Agent Relay, and the architecture is the story. Anthropic still runs the agent loop and the inference; tool calls execute in your workspace under your firewall, RBAC and audit, and the workspace dies when the session ends. His observed enterprise pattern: model quality clears the bar, and the deal dies when security asks where the code and credentials actually live.
https://x.com/ayyazdev/status/2100071328178991602
Coder wired Claude Code into Agent Relay, and the architecture is the story. Anthropic still runs the agent loop and the inference; tool calls execute in your workspace under your firewall, RBAC and audit, and the workspace dies when the session ends. His observed enterprise pattern: model quality clears the bar, and the deal dies when security asks where the code and credentials actually live.
#56
@AurevonLabs
https://x.com/AurevonLabs/status/2100186637476962642
Reduces the entire Anthropic product line to one question - who runs the agent loop, you or Anthropic. The SDK means you operate: Claude Code-class tools, loop and context management as a library running in your process. Managed agents mean Anthropic operates the agent and the sandbox infrastructure. Same idea of an agent, different owner of the runtime, and that ownership is what every procurement conversation is actually about.
https://x.com/AurevonLabs/status/2100186637476962642
Reduces the entire Anthropic product line to one question - who runs the agent loop, you or Anthropic. The SDK means you operate: Claude Code-class tools, loop and context management as a library running in your process. Managed agents mean Anthropic operates the agent and the sandbox infrastructure. Same idea of an agent, different owner of the runtime, and that ownership is what every procurement conversation is actually about.
#57
@DAssetBuzz
https://x.com/DAssetBuzz/status/2099869255172759554
Self-hosted agents are not an air gap. Moving tool execution onto your box still leaves the agent loop and inference in the vendor's cloud, and the tool outputs - code, diffs, terminal, screenshots - still leave the building for the model. His question is fair: would you still call it self-hosted if the thinking left the building?
https://x.com/DAssetBuzz/status/2099869255172759554
Self-hosted agents are not an air gap. Moving tool execution onto your box still leaves the agent loop and inference in the vendor's cloud, and the tool outputs - code, diffs, terminal, screenshots - still leave the building for the model. His question is fair: would you still call it self-hosted if the thinking left the building?
#58
@neilhamson
https://x.com/neilhamson/status/2099777270126694401
Breaks local into three different machines that people keep collapsing into one: weights on your disk with decode on someone else's GPU is a download, not local inference; weights in your VRAM with tool calls, search and the agent loop still leaving the box is local model with remote agency; and weights, decode, tools and write-back to memory all on hardware you control. The honest threshold is not a VRAM number, it is which model class you will run at the quant you will actually use with the context you need and no API in the loop.
https://x.com/neilhamson/status/2099777270126694401
Breaks local into three different machines that people keep collapsing into one: weights on your disk with decode on someone else's GPU is a download, not local inference; weights in your VRAM with tool calls, search and the agent loop still leaving the box is local model with remote agency; and weights, decode, tools and write-back to memory all on hardware you control. The honest threshold is not a VRAM number, it is which model class you will run at the quant you will actually use with the context you need and no API in the loop.
#59
@cai_smart
https://x.com/cai_smart/status/2100183163821539458
A careful review of a Claude Code skill pack, and the warning in it generalizes. Two of the five skills do not just add a slash command - they scaffold a scheduled GitHub Actions workflow into your repo that runs a coding agent on a schedule, plus a prompt, a memory file and reference templates. His caution is exactly right: read the generated workflow carefully before merging it, because you are committing CI that runs an agent on a timer.
https://x.com/cai_smart/status/2100183163821539458
A careful review of a Claude Code skill pack, and the warning in it generalizes. Two of the five skills do not just add a slash command - they scaffold a scheduled GitHub Actions workflow into your repo that runs a coding agent on a schedule, plus a prompt, a memory file and reference templates. His caution is exactly right: read the generated workflow carefully before merging it, because you are committing CI that runs an agent on a timer.
#60
@shivam74689
https://x.com/shivam74689/status/2100273866170056983
Day 112 of building in public, and the step that matters is connecting a retrieval layer into a bounded agent loop so the agent decides when a ticket needs supporting documentation instead of relying on the model's internal knowledge every time. He also added citation handling so retrieved knowledge is not injected and discarded - the final draft references the documentation it used, which makes the output traceable for a reviewer. His lesson: grounded generation matters more than fluent generation.
https://x.com/shivam74689/status/2100273866170056983
Day 112 of building in public, and the step that matters is connecting a retrieval layer into a bounded agent loop so the agent decides when a ticket needs supporting documentation instead of relying on the model's internal knowledge every time. He also added citation handling so retrieved knowledge is not injected and discarded - the final draft references the documentation it used, which makes the output traceable for a reviewer. His lesson: grounded generation matters more than fluent generation.
#61
@degenpark_eth
https://x.com/degenpark_eth/status/2100174409315029410
Argues validity transactions collapse a whole class of agent coordination. If a transaction carries its own preconditions and the chain validates them before inclusion, the agent can emit step two as a conditional transaction that only executes if step one's effects are visible, with no wrapper contract and no keeper network. What drops out of the stack is the polling loop, the check-then-send race, and the recovery logic for when that race is lost.
https://x.com/degenpark_eth/status/2100174409315029410
Argues validity transactions collapse a whole class of agent coordination. If a transaction carries its own preconditions and the chain validates them before inclusion, the agent can emit step two as a conditional transaction that only executes if step one's effects are visible, with no wrapper contract and no keeper network. What drops out of the stack is the polling loop, the check-then-send race, and the recovery logic for when that race is lost.
#62
@jefflinshu
https://x.com/jefflinshu/status/2100058183876354367
His working split is web ChatGPT to plan, Grok to execute, Codex to review, and his reasoning is about harness rather than intelligence. Codex's agent loop is built around code execution, so using it for research, PDFs or product discussion does not make those better, it just means a heavier loop and more context burned. Open-ended work goes to chat, engineering execution goes to Codex. He also notes he has stopped using the 1M context window and has not missed it.
https://x.com/jefflinshu/status/2100058183876354367
His working split is web ChatGPT to plan, Grok to execute, Codex to review, and his reasoning is about harness rather than intelligence. Codex's agent loop is built around code execution, so using it for research, PDFs or product discussion does not make those better, it just means a heavier loop and more context burned. Open-ended work goes to chat, engineering execution goes to Codex. He also notes he has stopped using the 1M context window and has not missed it.
#63
@Iktiarshovo12
https://x.com/Iktiarshovo12/status/2100436975966962074
Walks through MCP payment rails and states the problem plainly: an autonomous agent building a project needs real-time data, vector search and proof generation that each cost fractions of a cent, and redirecting to a human checkout page ruins the loop. With an MCP server exposing request_payment, check_status and get_session_budget, the model calls the payment tool the way it calls a file reader, settlement runs through a scoped session key, and the receipt hash comes back into the context window in about 1.8 seconds.
https://x.com/Iktiarshovo12/status/2100436975966962074
Walks through MCP payment rails and states the problem plainly: an autonomous agent building a project needs real-time data, vector search and proof generation that each cost fractions of a cent, and redirecting to a human checkout page ruins the loop. With an MCP server exposing request_payment, check_status and get_session_budget, the model calls the payment tool the way it calls a file reader, settlement runs through a scoped session key, and the receipt hash comes back into the context window in about 1.8 seconds.
#64
@bytecrafter_1
https://x.com/bytecrafter_1/status/2100231960912392392
A precise explanation of why coding agents drain budgets and translation does not. Each translation segment is independent, context never accumulates, and the system prompt is identical every call so almost everything hits cache - fan out to 50 languages and spend grows linearly with source length, nothing compounds. Coding agents resend the whole conversation plus tool schemas every turn. Point the same credits at a long agent loop and you will make a dent quickly.
https://x.com/bytecrafter_1/status/2100231960912392392
A precise explanation of why coding agents drain budgets and translation does not. Each translation segment is independent, context never accumulates, and the system prompt is identical every call so almost everything hits cache - fan out to 50 languages and spend grows linearly with source length, nothing compounds. Coding agents resend the whole conversation plus tool schemas every turn. Point the same credits at a long agent loop and you will make a dent quickly.
#65
@Bober_smart
https://x.com/Bober_smart/status/2100313298428186756
Breaks down how the Codex and ChatGPT teams optimize the agent loop layer by layer. The wrapper layer gathers context, sends it and runs the returned tool actions, and because network round trips and prompt reconstruction dominate every call they use persistent WebSockets and fixed prompt prefixes. The API layer validates, safety-checks and tokenizes, so they use delta tokenization and parallel safety evaluation. The inference layer uses cache-aware routing, speculative decoding and separated prefill and decode stages. One principle underneath all of it: never pay for identical computations twice.
https://x.com/Bober_smart/status/2100313298428186756
Breaks down how the Codex and ChatGPT teams optimize the agent loop layer by layer. The wrapper layer gathers context, sends it and runs the returned tool actions, and because network round trips and prompt reconstruction dominate every call they use persistent WebSockets and fixed prompt prefixes. The API layer validates, safety-checks and tokenizes, so they use delta tokenization and parallel safety evaluation. The inference layer uses cache-aware routing, speculative decoding and separated prefill and decode stages. One principle underneath all of it: never pay for identical computations twice.
#66
@ElInsuranceGuy
https://x.com/ElInsuranceGuy/status/2100615937019859147
A clean statement of a latency constraint people keep forgetting. Tabular foundation models predict with zero training, but one call takes 12.6 seconds on CPU - you cannot put that inside an interactive agent loop, because nobody waits 88 seconds for a what-if answer. Per-call latency stops being a nice-to-have the moment a human is waiting at the end of a chain of them.
https://x.com/ElInsuranceGuy/status/2100615937019859147
A clean statement of a latency constraint people keep forgetting. Tabular foundation models predict with zero training, but one call takes 12.6 seconds on CPU - you cannot put that inside an interactive agent loop, because nobody waits 88 seconds for a what-if answer. Per-call latency stops being a nice-to-have the moment a human is waiting at the end of a chain of them.
#67
@SepandD
https://x.com/SepandD/status/2099948169664852010
The uncomfortable observation of the window: the hype cycle now moves fast enough that it is actively beneficial for someone's autoresearch system to make eval mistakes that flatter the results. By the time anyone notices, the praise is collected and the work is forgotten, and nobody cares that the score was computed on half the validation set. He says he has run into this several times with vision eval results and is deliberately slowing his own release to triple-check.
https://x.com/SepandD/status/2099948169664852010
The uncomfortable observation of the window: the hype cycle now moves fast enough that it is actively beneficial for someone's autoresearch system to make eval mistakes that flatter the results. By the time anyone notices, the praise is collected and the work is forgotten, and nobody cares that the score was computed on half the validation set. He says he has run into this several times with vision eval results and is deliberately slowing his own release to triple-check.
#68
@SpenzDigital
https://x.com/SpenzDigital/status/2100612769934688377
On unofficial clients, the correct wiring is existing login, one agent core, desktop app as a thin view. Wrappers that smuggle in a second agent loop rot the same way every time: two behaviours, one set of evals, covering neither.
https://x.com/SpenzDigital/status/2100612769934688377
On unofficial clients, the correct wiring is existing login, one agent core, desktop app as a thin view. Wrappers that smuggle in a second agent loop rot the same way every time: two behaviours, one set of evals, covering neither.
#69
@winzheng_lab
https://x.com/winzheng_lab/status/2099684867802046467
Agent loop polling is a quota killer, and they see the same drain running multi-step code evaluation tasks. Their point is that benchmark scores never capture per-task API cost, which is arguably as important as raw capability - a number the entire harness-comparison literature this week has been converging on independently.
https://x.com/winzheng_lab/status/2099684867802046467
Agent loop polling is a quota killer, and they see the same drain running multi-step code evaluation tasks. Their point is that benchmark scores never capture per-task API cost, which is arguably as important as raw capability - a number the entire harness-comparison literature this week has been converging on independently.
#70
@AfterThe925
https://x.com/AfterThe925/status/2099928324436787361
Does the arithmetic on the Claude Code meter change. The summer 50% weekly boost ended on September 13 and the new permanent floor is 25% above pre-May, which against the meter you planned around all summer is about 17% less. Auto-mode classification no longer burns weekly quota. His instruction is the practical one: if one command kicks off eight to twelve tool calls, the weekly cap is the product - run /usage, write the real number down, and plan the next agent loop against that rather than the marketing line.
https://x.com/AfterThe925/status/2099928324436787361
Does the arithmetic on the Claude Code meter change. The summer 50% weekly boost ended on September 13 and the new permanent floor is 25% above pre-May, which against the meter you planned around all summer is about 17% less. Auto-mode classification no longer burns weekly quota. His instruction is the practical one: if one command kicks off eight to twelve tool calls, the weekly cap is the product - run /usage, write the real number down, and plan the next agent loop against that rather than the marketing line.
π‘ Eco Products Radar
Eco Products Radar
Dream-RSI - the frozen-weights recursive self-improvement result, discussed from at least four directions this window.
OpenResearch - the local-first autoresearch workspace turning Claude Code, Codex and OpenCode into research agents with isolated worktrees.
Claude Code - still the default substrate underneath most of these loops, and the subject of the window's meter arithmetic.
Codex - the loop people read line by line to find out how a shipped agent runtime is actually structured.
Jev - the typed-decision model being wired in as a decision layer with generation removed from the loop entirely.
DeepSeek Harness - the fully unbundled harness where the agent loop itself is a swappable plugin.
Pi - the minimal harness that keeps winning the cost half of every harness comparison.
Hermes - the self-improving-skills harness now shipping a reviewed plugin catalog with SHA-pinning.
MCP - the connective layer under most of these, now being extended toward payment rails.
Dream-RSI - the frozen-weights recursive self-improvement result, discussed from at least four directions this window.
OpenResearch - the local-first autoresearch workspace turning Claude Code, Codex and OpenCode into research agents with isolated worktrees.
Claude Code - still the default substrate underneath most of these loops, and the subject of the window's meter arithmetic.
Codex - the loop people read line by line to find out how a shipped agent runtime is actually structured.
Jev - the typed-decision model being wired in as a decision layer with generation removed from the loop entirely.
DeepSeek Harness - the fully unbundled harness where the agent loop itself is a swappable plugin.
Pi - the minimal harness that keeps winning the cost half of every harness comparison.
Hermes - the self-improving-skills harness now shipping a reviewed plugin catalog with SHA-pinning.
MCP - the connective layer under most of these, now being extended toward payment rails.
Comments