Loop Daily: 2026-10-18
The barrier to frontier autoresearch dropped to zero this weekend. A free model, OpenCode's Space Bunny Max, set the integer-multiplication record four times in a row, with Opus 5.5 verifying and pushing the PRs over the line, and the organizer's read is that a model trained on different data is just another way out of a local minimum, alongside forgetting, branching and fork-and-flush. The repo logged 850 PRs from 67 contributors in two days, 21 of them first-timers, Codex in 56 percent, Claude in 17, OpenCode in 7, and the share of PRs citing a prior research-only submission went from near zero to half after one prompt file. The rest of the day was about what happens around the loop. A paper found the best frontier model can build only 53 percent of a coding-agent harness correctly from a spec, with failures at the seams between modules. A new game-playing harness treats API latency as part of the environment, giving Sol the mean, P90 and P95 and letting it plan for where the boss will be. A weekend hill-climb on a Rust vector search library had GLM 5.3 Flash triple query throughput in eight iterations while DeepSeek 4.1 Flash gained 15 percent on the same prompt. A quantum simulator paper ships with an autoresearch harness that proposes and benchmarks optimizations against physics tests. And the plumbing kept getting measured: Gemini's prompt cache missed 27 percent of the time in a loop where Claude and GPT hit 100, Opus 5.5 at max effort costs slightly more per task than Opus 5 because it says 119,000 tokens instead of 73,000, and a 4B decision model at a cent per million tokens is now cheap enough to grade every step.
#1
@RohanArun
https://x.com/RohanArun/status/2111568465223925936
RohanArun posts the integer-multiplication highlights since October 15, kappa from 2 to the minus 182 to 0.001734815770, up 1.23 percent. The headline is that a free model, OpenCode's Space Bunny Max, set the record for the first time, four times in a row, with Claude Opus 5.5 verifying and pushing the PRs over the line; a frontier verifier is still recommended but other contributors can supply it. A community Lean proof of the original OpenAI paper was completed in six days and the main repo is 10 to 20 percent verified. After one autoresearch.md prompt that routes newcomers to specific research tracks, 41 to 51 percent of PRs now cite a prior research-only submission, up from 0 to 3. Stats: 850 PRs from 67 contributors, 21 first-timers, 55 claiming a new bound, Codex in 480 (56 percent), Claude in 147, OpenCode in 60, Cursor in 16. A side finding: rewinding the repo to an earlier branch makes a benchmark for harnesses and context designs, and distilling to local files then concatenating them into parallel sessions saved 10 to 20 percent of time to the next breakthrough.
https://x.com/RohanArun/status/2111568465223925936
RohanArun posts the integer-multiplication highlights since October 15, kappa from 2 to the minus 182 to 0.001734815770, up 1.23 percent. The headline is that a free model, OpenCode's Space Bunny Max, set the record for the first time, four times in a row, with Claude Opus 5.5 verifying and pushing the PRs over the line; a frontier verifier is still recommended but other contributors can supply it. A community Lean proof of the original OpenAI paper was completed in six days and the main repo is 10 to 20 percent verified. After one autoresearch.md prompt that routes newcomers to specific research tracks, 41 to 51 percent of PRs now cite a prior research-only submission, up from 0 to 3. Stats: 850 PRs from 67 contributors, 21 first-timers, 55 claiming a new bound, Codex in 480 (56 percent), Claude in 147, OpenCode in 60, Cursor in 16. A side finding: rewinding the repo to an earlier branch makes a benchmark for harnesses and context designs, and distilling to local files then concatenating them into parallel sessions saved 10 to 20 percent of time to the next breakthrough.
#2
@RohanArun
https://x.com/RohanArun/status/2111493670318809303
RohanArun explains why a free model mattered: models get stuck in local minima of the solution space, and switching models used to be the way to get fresh ideas. The post maps the same move onto the recent context-engineering fixes, forgetting context to refresh, branching into different solutions, and fork-and-flush, and adds a fourth, a completely new model with a differently trained solution space, which now includes free ones. The proposal is to sweep all models, free and paid, with contributors on free models submitting ideas and others verifying with frontier models, since Opus kept improving on each Space Bunny idea. Progress had been slowing in the last day until Space Bunny injected fresh candidates.
https://x.com/RohanArun/status/2111493670318809303
RohanArun explains why a free model mattered: models get stuck in local minima of the solution space, and switching models used to be the way to get fresh ideas. The post maps the same move onto the recent context-engineering fixes, forgetting context to refresh, branching into different solutions, and fork-and-flush, and adds a fourth, a completely new model with a differently trained solution space, which now includes free ones. The proposal is to sweep all models, free and paid, with contributors on free models submitting ideas and others verifying with frontier models, since Opus kept improving on each Space Bunny idea. Progress had been slowing in the last day until Space Bunny injected fresh candidates.
#3
@wzenus
https://x.com/wzenus/status/2111283947858698404
wzenus released Sooool, a repo where Sol plays games frame by frame with no code-as-policy, and the research loop is built around the delay between seeing a frame and the action landing. Up to eight model requests run in parallel so Sol keeps looking at new frames while earlier decisions are in flight. During development the target API's latency is profiled and simulated with cheaper inference, only the delay is faked, Sol still sees frames and chooses. Sol is given latency mean, std, P90 and P95 so it can plan for where things will be when the action arrives. Episodes run, failures are inspected, Sol decides which lessons enter later prompts. Budget is about 50 dollars per task on paid calls, mostly final verification. Lessons Sol wrote for Touhou: predict where the boss will be, not where it was; check the move and the waiting position; more damage is not enough if it costs more hits.
https://x.com/wzenus/status/2111283947858698404
wzenus released Sooool, a repo where Sol plays games frame by frame with no code-as-policy, and the research loop is built around the delay between seeing a frame and the action landing. Up to eight model requests run in parallel so Sol keeps looking at new frames while earlier decisions are in flight. During development the target API's latency is profiled and simulated with cheaper inference, only the delay is faked, Sol still sees frames and chooses. Sol is given latency mean, std, P90 and P95 so it can plan for where things will be when the action arrives. Episodes run, failures are inspected, Sol decides which lessons enter later prompts. Budget is about 50 dollars per task on paid calls, mostly final verification. Lessons Sol wrote for Touhou: predict where the boss will be, not where it was; check the move and the waiting position; more damage is not enough if it costs more hits.
#4
@Harman26Singh
https://x.com/Harman26Singh/status/2111326644417749371
Harman26Singh connects the forgetting paper to a year of work on evolutionary systems and self-verification. In verifier-free evolution combining parallel and sequential reasoning, truncating reasoning traces and keeping only final answers before aggregation often worked better, and removing traces made models reason longer while keeping them made models conservative and quick to terminate, consistent with the paper's finding that forgetting raised median reasoning tokens from 2.9K to 9.4K per proposal and produced larger code edits. In self-verification, performance improved when the model saw only the final answer without the trace that produced it, the intuition being that models are biased toward their own answers and cross-family verification works better. The open question is whether autoresearch agents are implicitly self-verifying their own proposals, so better self-verification after forgetting may be part of the gain.
https://x.com/Harman26Singh/status/2111326644417749371
Harman26Singh connects the forgetting paper to a year of work on evolutionary systems and self-verification. In verifier-free evolution combining parallel and sequential reasoning, truncating reasoning traces and keeping only final answers before aggregation often worked better, and removing traces made models reason longer while keeping them made models conservative and quick to terminate, consistent with the paper's finding that forgetting raised median reasoning tokens from 2.9K to 9.4K per proposal and produced larger code edits. In self-verification, performance improved when the model saw only the final answer without the trace that produced it, the intuition being that models are biased toward their own answers and cross-family verification works better. The open question is whether autoresearch agents are implicitly self-verifying their own proposals, so better self-verification after forgetting may be part of the gain.
#5
@YizheZhangNLP
https://x.com/YizheZhangNLP/status/2111505651533070339
YizheZhangNLP, on work done at Apple, argues autoresearch may surpass humans when strong models are harnessed right, and that models can be trained to get increasingly effective at autoresearch, creating a self-reinforcing cycle. A reply asked whether this is auto-research rather than recursive self-improvement, since it is not the model improving itself, and a second reply suggested an autoresearch-like loop could eventually be post-trained into models, with benchmarks like this generating the traces to get there.
https://x.com/YizheZhangNLP/status/2111505651533070339
YizheZhangNLP, on work done at Apple, argues autoresearch may surpass humans when strong models are harnessed right, and that models can be trained to get increasingly effective at autoresearch, creating a self-reinforcing cycle. A reply asked whether this is auto-research rather than recursive self-improvement, since it is not the model improving itself, and a second reply suggested an autoresearch-like loop could eventually be post-trained into models, with benchmarks like this generating the traces to get there.
#6
@sukin_s
https://x.com/sukin_s/status/2111009285971087627
sukin_s turns the forgetting paper into production rules. Long-running agents rarely fail by crashing, they fail by plateauing, and one agent running longer, parallel agents and communicating teams all flatten before the budget ends. Six takeaways: watch for shrinking work, not just flat scores, since on AHC014 edits per proposal fell from about 150 lines to 30 and thinking tokens from 28K to 7K before the first forget; decide what survives a reset, in the paper one thing, the best candidate and its score; drop more than chat history, including earlier candidates and workspace history; restart with an empty context and the original instructions, not a summary; forget on a schedule, three times, splitting the budget into four rounds; pair resets with shared results, since four agents that see each other's candidates plus forgetting beat parallel agents by 10 percent and a single agent by 22 at the same budget.
https://x.com/sukin_s/status/2111009285971087627
sukin_s turns the forgetting paper into production rules. Long-running agents rarely fail by crashing, they fail by plateauing, and one agent running longer, parallel agents and communicating teams all flatten before the budget ends. Six takeaways: watch for shrinking work, not just flat scores, since on AHC014 edits per proposal fell from about 150 lines to 30 and thinking tokens from 28K to 7K before the first forget; decide what survives a reset, in the paper one thing, the best candidate and its score; drop more than chat history, including earlier candidates and workspace history; restart with an empty context and the original instructions, not a summary; forget on a schedule, three times, splitting the budget into four rounds; pair resets with shared results, since four agents that see each other's candidates plus forgetting beat parallel agents by 10 percent and a single agent by 22 at the same budget.
#7
@al3rez
https://x.com/al3rez/status/2111268459107733706
al3rez summarizes Doc2Harness, a paper testing whether frontier models can build complete coding-agent harnesses from specifications. Nineteen models each got an interface contract and a design document derived from 12 existing harnesses and had to implement a working harness from scratch; implementations were frozen and run against 328 deterministic tests on model requests, filesystem state, exit codes and command output. The best model passed 53.05 percent, the weakest 27.44. Failures clustered where functionality crossed module boundaries, a tool call working alone but breaking when it touched context management or process state. The conclusion is that writing an agent loop is relatively easy and making every component behave across a long session is the hard part, so future evaluations should include crash recovery, concurrent tools, compaction and state consistency.
https://x.com/al3rez/status/2111268459107733706
al3rez summarizes Doc2Harness, a paper testing whether frontier models can build complete coding-agent harnesses from specifications. Nineteen models each got an interface contract and a design document derived from 12 existing harnesses and had to implement a working harness from scratch; implementations were frozen and run against 328 deterministic tests on model requests, filesystem state, exit codes and command output. The best model passed 53.05 percent, the weakest 27.44. Failures clustered where functionality crossed module boundaries, a tool call working alone but breaking when it touched context management or process state. The conclusion is that writing an agent loop is relatively easy and making every component behave across a long session is the hard part, so future evaluations should include crash recovery, concurrent tools, compaction and state consistency.
#8
@LearnStochastic
https://x.com/LearnStochastic/status/2111426150014787935
LearnStochastic handed their own Rust vector search library to an agent in auto-research mode over the weekend, with the instruction to hill-climb write throughput and read QPS and stop after five iterations without improvement. GLM 5.3 Flash tripled QPS and doubled throughput in about eight iterations. DeepSeek 4.1 Flash almost doubled write throughput but gained barely 15 percent on QPS. Same prompt, same experimental setup, both through the OpenCode harness.
https://x.com/LearnStochastic/status/2111426150014787935
LearnStochastic handed their own Rust vector search library to an agent in auto-research mode over the weekend, with the instruction to hill-climb write throughput and read QPS and stop after five iterations without improvement. GLM 5.3 Flash tripled QPS and doubled throughput in about eight iterations. DeepSeek 4.1 Flash almost doubled write throughput but gained barely 15 percent on QPS. Same prompt, same experimental setup, both through the OpenCode harness.
#9
@AntoineTilloy
https://x.com/AntoineTilloy/status/2111364598469173563
AntoineTilloy has been vibe-exploring explicit fast matrix multiplication algorithms using auto-research with sparse human steering. The objective is to lower the exponent of matrix multiplication without producing a galactic algorithm: naive is n cubed, the best known is n to the 2.25 but impractical, and the question is whether something in between can be found.
https://x.com/AntoineTilloy/status/2111364598469173563
AntoineTilloy has been vibe-exploring explicit fast matrix multiplication algorithms using auto-research with sparse human steering. The objective is to lower the exponent of matrix multiplication without producing a galactic algorithm: naive is n cubed, the best known is n to the 2.25 but impractical, and the question is whether something in between can be found.
#10
@iamMrDuncan
https://x.com/iamMrDuncan/status/2111564596041441346
iamMrDuncan's Thermite now supports three types of auto-research: hill-climbing to improve a stat, goal achievement to prove a hypothesis, and deep research to compile a report. An earlier post describes it as a true autoresearch platform for scientific and engineering work across multiple machines and multiple research campaigns, one of two harnesses being built to work together.
https://x.com/iamMrDuncan/status/2111564596041441346
iamMrDuncan's Thermite now supports three types of auto-research: hill-climbing to improve a stat, goal achievement to prove a hypothesis, and deep research to compile a report. An earlier post describes it as a true autoresearch platform for scientific and engineering work across multiple machines and multiple research campaigns, one of two harnesses being built to work together.
#11
@mr_bytestorm
https://x.com/mr_bytestorm/status/2111151318719144032
mr_bytestorm is running one autoresearch agent on an ML research problem and a second autoresearch agent on the autoresearch harness itself, optimizing the harness for return on investment over the first loop. Described as quite fun to watch.
https://x.com/mr_bytestorm/status/2111151318719144032
mr_bytestorm is running one autoresearch agent on an ML research problem and a second autoresearch agent on the autoresearch harness itself, optimizing the harness for return on investment over the first loop. Described as quite fun to watch.
#12
@rogerluorl18
https://x.com/rogerluorl18/status/2111557713247293601
rogerluorl18 announces the PPVM paper on arXiv, a step toward digital twins for fault-tolerant quantum computers at the 10,000-physical-qubit scale that bring quantum operations, hardware noise, classical control and decoding together so failures can be traced through the system. It specifies noise channels for neutral-atom arrays including state-dependent and correlated atom loss, powers Bloqade QEC Studio, and, in the part relevant here, explores how scientific software gets built: an autoresearch-inspired harness lets AI agents propose and benchmark performance optimizations, checked against reference implementations and physics tests. Work with QuEra and NVIDIA collaborators.
https://x.com/rogerluorl18/status/2111557713247293601
rogerluorl18 announces the PPVM paper on arXiv, a step toward digital twins for fault-tolerant quantum computers at the 10,000-physical-qubit scale that bring quantum operations, hardware noise, classical control and decoding together so failures can be traced through the system. It specifies noise channels for neutral-atom arrays including state-dependent and correlated atom loss, powers Bloqade QEC Studio, and, in the part relevant here, explores how scientific software gets built: an autoresearch-inspired harness lets AI agents propose and benchmark performance optimizations, checked against reference implementations and physics tests. Work with QuEra and NVIDIA collaborators.
#13
@NeedlAi
https://x.com/NeedlAi/status/2111087266043212190
NeedlAi published a technical whitepaper with AWS on document AI cost. The biggest cost decision is how many pages you send to the model, not which model: most documents already have their text, a few are hard, so every document is routed to the lowest-cost option that still clears the quality bar. On the retrieval side they run no vector database, since retrieval errors compound across an agent's steps and vector search hits an accuracy ceiling as the corpus grows; documents are indexed whole on Amazon OpenSearch, chunked at query time, and queried by an agentic loop that plans, retrieves and repeats until the answer is grounded. On OfficeQA Pro, 133 questions over 89,000 pages of financial documents, they report 16.5 points more accuracy than the best published harness, 13 times faster and 5 times cheaper per question.
https://x.com/NeedlAi/status/2111087266043212190
NeedlAi published a technical whitepaper with AWS on document AI cost. The biggest cost decision is how many pages you send to the model, not which model: most documents already have their text, a few are hard, so every document is routed to the lowest-cost option that still clears the quality bar. On the retrieval side they run no vector database, since retrieval errors compound across an agent's steps and vector search hits an accuracy ceiling as the corpus grows; documents are indexed whole on Amazon OpenSearch, chunked at query time, and queried by an agentic loop that plans, retrieves and repeats until the answer is grounded. On OfficeQA Pro, 133 questions over 89,000 pages of financial documents, they report 16.5 points more accuracy than the best published harness, 13 times faster and 5 times cheaper per question.
#14
@_krish00
https://x.com/_krish00/status/2111461648036942327
_krish00 used Muse Wonder for 48 hours straight on multi-file refactors and agentic loops. The good: Active Focus is real, where most models get lazy 15 steps into a broken migration and start editing tests to pass, Wonder backtracks, spawns subtasks and grinds through blockers; state tracking over the 1M window holds when constraints change mid-session. The bad: about 4.5 percent tool-call and structured-output error rates in the wild, which compounds fast over a 20-step loop and demands solid retry and validation in the harness; brutal tail latency when thinking kicks in; 4 and 20 dollars per million means autonomous loops burn cash; and Wonder Full is locked behind Muse Code subscriptions with no open weights. Verdict: trails on greenfield builds and terminal speed, at the frontier for long-horizon planning and migrations.
https://x.com/_krish00/status/2111461648036942327
_krish00 used Muse Wonder for 48 hours straight on multi-file refactors and agentic loops. The good: Active Focus is real, where most models get lazy 15 steps into a broken migration and start editing tests to pass, Wonder backtracks, spawns subtasks and grinds through blockers; state tracking over the 1M window holds when constraints change mid-session. The bad: about 4.5 percent tool-call and structured-output error rates in the wild, which compounds fast over a 20-step loop and demands solid retry and validation in the harness; brutal tail latency when thinking kicks in; 4 and 20 dollars per million means autonomous loops burn cash; and Wonder Full is locked behind Muse Code subscriptions with no open weights. Verdict: trails on greenfield builds and terminal speed, at the frontier for long-horizon planning and migrations.
#15
@kspringfield13
https://x.com/kspringfield13/status/2111569286544183802
kspringfield13 measured prompt cache behavior in an agent loop: Gemini's cache went 167 for 228, a 27 percent miss tax and up to 1.48 times the bill, while Claude and GPT both hit 100 percent on the same workload. A reply argued the system prompt and early turns barely change in a loop so hits should be nearly free, and that a 1.48x multiplier across hundreds of agent sessions a day is thousands a month on tokens that should have cost nothing; cache hit rate is a pricing lever disguised as an infra detail.
https://x.com/kspringfield13/status/2111569286544183802
kspringfield13 measured prompt cache behavior in an agent loop: Gemini's cache went 167 for 228, a 27 percent miss tax and up to 1.48 times the bill, while Claude and GPT both hit 100 percent on the same workload. A reply argued the system prompt and early turns barely change in a loop so hits should be nearly free, and that a 1.48x multiplier across hundreds of agent sessions a day is thousands a month on tokens that should have cost nothing; cache hit rate is a pricing lever disguised as an infra detail.
#16
@stretchcloud
https://x.com/stretchcloud/status/2111389756932174106
stretchcloud reads the Opus 5.5 pricing story from the cost-per-task side. The launch cut list prices from 5 and 25 to 4 and 20 per million with cache reads from 0.50 to 0.20, and Anthropic claims 30 percent faster and 40 percent cheaper on typical workloads, with SWE-bench Pro from 79.2 to 89.9 and Terminal-Bench from 52.3 to 66.4. But Artificial Analysis measured cost per completed task at max effort and found Opus 5.5 slightly more expensive than Opus 5, 5.98 versus 5.86 dollars, because it generates about 119,000 output tokens per task against 73,000. The savings show up at lower effort settings, which matters if you run it inside an agent loop and never check the default. Against GPT-6 Astra Max it leads the index 57.62 to 52.67 but Astra is cheaper per task because it says less.
https://x.com/stretchcloud/status/2111389756932174106
stretchcloud reads the Opus 5.5 pricing story from the cost-per-task side. The launch cut list prices from 5 and 25 to 4 and 20 per million with cache reads from 0.50 to 0.20, and Anthropic claims 30 percent faster and 40 percent cheaper on typical workloads, with SWE-bench Pro from 79.2 to 89.9 and Terminal-Bench from 52.3 to 66.4. But Artificial Analysis measured cost per completed task at max effort and found Opus 5.5 slightly more expensive than Opus 5, 5.98 versus 5.86 dollars, because it generates about 119,000 output tokens per task against 73,000. The savings show up at lower effort settings, which matters if you run it inside an agent loop and never check the default. Against GPT-6 Astra Max it leads the index 57.62 to 52.67 but Astra is cheaper per task because it says less.
#17
@stretchcloud
https://x.com/stretchcloud/status/2111258894177829216
stretchcloud relays Thorsten Ball's question, why are you still using pull requests, backed by Ampcode pushing straight to main with no mandatory review gate: if Opus 5.5, Fable and Astra can each check a diff four times in parallel, what is a human skim catching. Agent-authored PRs now outpace human ones on GitHub by some counts and the review layer has become a market: CodeRabbit at 24 to 72 dollars a seat, Greptile indexing a repo into a semantic graph with 50 free reviews a month, Qodo's paid tier, Graphite's Diamond inside a merge queue, Cursor's Bugbot billed per run at about a dollar. The missing piece is that review was never only bug catching, it is how juniors learn the codebase and how someone later learns why a workaround exists. The guess: PRs stop being the review mechanism and become the audit trail, with the actual review moving into the agent loop.
https://x.com/stretchcloud/status/2111258894177829216
stretchcloud relays Thorsten Ball's question, why are you still using pull requests, backed by Ampcode pushing straight to main with no mandatory review gate: if Opus 5.5, Fable and Astra can each check a diff four times in parallel, what is a human skim catching. Agent-authored PRs now outpace human ones on GitHub by some counts and the review layer has become a market: CodeRabbit at 24 to 72 dollars a seat, Greptile indexing a repo into a semantic graph with 50 free reviews a month, Qodo's paid tier, Graphite's Diamond inside a merge queue, Cursor's Bugbot billed per run at about a dollar. The missing piece is that review was never only bug catching, it is how juniors learn the codebase and how someone later learns why a workaround exists. The guess: PRs stop being the review mechanism and become the audit trail, with the actual review moving into the agent loop.
#18
@peterpme
https://x.com/peterpme/status/2111130822208111015
peterpme gives the core idea behind always-on agents like Grok Bot in a few lines: a durable agent is a normal agent loop with a wrapper around every step. If there is a saved result, return it; if not, run it and save it; if it crashes mid turn, rerun from the top and it fast-forwards to where it died. That is enough to be a systems-level engineer capable of building agents.
https://x.com/peterpme/status/2111130822208111015
peterpme gives the core idea behind always-on agents like Grok Bot in a few lines: a durable agent is a normal agent loop with a wrapper around every step. If there is a saved result, return it; if not, run it and save it; if it crashes mid turn, rerun from the top and it fast-forwards to where it died. That is enough to be a systems-level engineer capable of building agents.
#19
@SiftByte
https://x.com/SiftByte/status/2111545185956208901
SiftByte describes the architecture behind Grok Bot and why it keeps working after the laptop closes: it is built to sleep by default. Three parts, thin clients on desktop, phone, Slack and email, a thick server where the agent loop runs, and a cloud computer, a Firecracker microVM, used for browsing, commands and file edits. A message, schedule or event wakes it, it loads state from a database, restores the VM from a snapshot if needed and runs the loop, LLM plus tools. Durable workflows on Temporal mean a crash resumes from the last completed step. When work is done it saves state, snapshots the VM and sleeps. The state lives outside any running process; the model is one piece and the real engineering is in sleeping, resuming and using its own computer.
https://x.com/SiftByte/status/2111545185956208901
SiftByte describes the architecture behind Grok Bot and why it keeps working after the laptop closes: it is built to sleep by default. Three parts, thin clients on desktop, phone, Slack and email, a thick server where the agent loop runs, and a cloud computer, a Firecracker microVM, used for browsing, commands and file edits. A message, schedule or event wakes it, it loads state from a database, restores the VM from a snapshot if needed and runs the loop, LLM plus tools. Durable workflows on Temporal mean a crash resumes from the last completed step. When work is done it saves state, snapshots the VM and sleeps. The state lives outside any running process; the model is one piece and the real engineering is in sleeping, resuming and using its own computer.
#20
@jbish1572
https://x.com/jbish1572/status/2111275552455946471
jbish1572 notes that Perplexity open-sourced a new pair of decision models, and that the small 4B one costs about a cent per million tokens, cheap enough to put a check on every step of an agent loop instead of trusting the big model to grade itself. Replies asked how the 4B does on calibration, and pointed out that it is the third decider release in about two weeks and small enough to run next to the hot path rather than behind an API call.
https://x.com/jbish1572/status/2111275552455946471
jbish1572 notes that Perplexity open-sourced a new pair of decision models, and that the small 4B one costs about a cent per million tokens, cheap enough to put a check on every step of an agent loop instead of trusting the big model to grade itself. Replies asked how the 4B does on calibration, and pointed out that it is the third decider release in about two weeks and small enough to run next to the hot path rather than behind an API call.
#21
@0XanderVance
https://x.com/0XanderVance/status/2111523658334367852
0XanderVance wired a small agent loop on Saturday that pulls the three worst warehouse scan mismatches. Matching phone photos to purchase-order lines by hand used to take 40 minutes; now the flagged ones get reviewed and the batch is closed in under five.
https://x.com/0XanderVance/status/2111523658334367852
0XanderVance wired a small agent loop on Saturday that pulls the three worst warehouse scan mismatches. Matching phone photos to purchase-order lines by hand used to take 40 minutes; now the flagged ones get reviewed and the batch is closed in under five.
#22
@ZikuD_s
https://x.com/ZikuD_s/status/2111099939929333940
ZikuD_s, asked whether autoresearch gains come from the model or the harness, answers a bit of both: after trying auto-research on several different problems the harness turned out to be surprisingly task-dependent and had to be tuned for each one, which is why harness engineering is still a real bottleneck. A follow-up adds that they built their own internal auto-research harness as one way through it.
https://x.com/ZikuD_s/status/2111099939929333940
ZikuD_s, asked whether autoresearch gains come from the model or the harness, answers a bit of both: after trying auto-research on several different problems the harness turned out to be surprisingly task-dependent and had to be tuned for each one, which is why harness engineering is still a real bottleneck. A follow-up adds that they built their own internal auto-research harness as one way through it.
#23
@fradamt
https://x.com/fradamt/status/2111340867172610253
fradamt, on Ethereum's autoresearch challenges, reports not yet having a good way to set up proper challenges for decoupled consensus because it is hard to specify all the properties that must hold, and recommends contributing to the existing challenges for now. An experiment with a smaller, better-defined question is underway and will be posted if something comes out of it.
https://x.com/fradamt/status/2111340867172610253
fradamt, on Ethereum's autoresearch challenges, reports not yet having a good way to set up proper challenges for decoupled consensus because it is hard to specify all the properties that must hold, and recommends contributing to the existing challenges for now. An experiment with a smaller, better-defined question is underway and will be posted if something comes out of it.
#24
@BasedCampZH
https://x.com/BasedCampZH/status/2111142272179810545
BasedCampZH describes how Mnemma has leaned into the pain of constantly replacing its own solutions: today it is an in-memory knowledge graph optimized through auto-research for the inheritance loop it is used in, abstracting over an on-disk graph that acts as the source of truth. Tomorrow it may be something else, and the expectation is a better mousetrap for the same pain every quarter.
https://x.com/BasedCampZH/status/2111142272179810545
BasedCampZH describes how Mnemma has leaned into the pain of constantly replacing its own solutions: today it is an in-memory knowledge graph optimized through auto-research for the inheritance loop it is used in, abstracting over an on-disk graph that acts as the source of truth. Tomorrow it may be something else, and the expectation is a better mousetrap for the same pain every quarter.
#25
@regents_sh
https://x.com/regents_sh/status/2111198654816305552
regents_sh compiles the autoresearch stalls thread in four links: forget all but the best for plus 39 percent, fork-and-flush to escape idea basins, self-play agents that co-cheat, and Sakana's MASS where agents grade agents.
https://x.com/regents_sh/status/2111198654816305552
regents_sh compiles the autoresearch stalls thread in four links: forget all but the best for plus 39 percent, fork-and-flush to escape idea basins, self-play agents that co-cheat, and Sakana's MASS where agents grade agents.
#26
@clawement
https://x.com/clawement/status/2111548312083955736
clawement reports twelve days of its own records before a move, October 1 to 12: 12,978 commits from 46 agents in 204 working sessions. By engine, Claude Code carried 11,297 commits in 136 sessions and Codex 1,235 in five, almost all from one agent whose Codex sessions selected gpt-6-astra and gpt-6; 9,853 commits name Claude Opus 5.5 as co-author. Between agents, 6,210 messages passed, 1,336 of them receipts for an ask taken or closed, with the two busiest exchanging 657 and 549. The closing line: a commit is a unit of saved work, not a measure of its worth.
https://x.com/clawement/status/2111548312083955736
clawement reports twelve days of its own records before a move, October 1 to 12: 12,978 commits from 46 agents in 204 working sessions. By engine, Claude Code carried 11,297 commits in 136 sessions and Codex 1,235 in five, almost all from one agent whose Codex sessions selected gpt-6-astra and gpt-6; 9,853 commits name Claude Opus 5.5 as co-author. Between agents, 6,210 messages passed, 1,336 of them receipts for an ask taken or closed, with the two busiest exchanging 657 and 549. The closing line: a commit is a unit of saved work, not a measure of its worth.
#27
@ValonHajredini
https://x.com/ValonHajredini/status/2111397108859146477
ValonHajredini flags a preprint that audited four self-improving agent methods under skill drift, the situation where an agent's skills get edited after deployment: 52 to 93 percent of the skill bank's gain disappeared. The suggestion is to test agents against drifted skills before shipping.
https://x.com/ValonHajredini/status/2111397108859146477
ValonHajredini flags a preprint that audited four self-improving agent methods under skill drift, the situation where an agent's skills get edited after deployment: 52 to 93 percent of the skill bank's gain disappeared. The suggestion is to test agents against drifted skills before shipping.
#28
@CNopenmodels
https://x.com/CNopenmodels/status/2111248498481848438
CNopenmodels reports BAAI's AREX-2, a 27B self-improving agent that learns to reflect and revise over multiple test-time rounds, Apache 2.0, 262K context, pitched for long-horizon reasoning.
https://x.com/CNopenmodels/status/2111248498481848438
CNopenmodels reports BAAI's AREX-2, a 27B self-improving agent that learns to reflect and revise over multiple test-time rounds, Apache 2.0, 262K context, pitched for long-horizon reasoning.
#29
@SepecziDre72128
https://x.com/SepecziDre72128/status/2111105196738650401
SepecziDre72128 found almost every For You scan hitting a 429 because the agent loop re-sent about 100KB of tool output every step, six steps, three refreshes in five seconds. The fix was to stop letting the model rediscover Gmail: direct app reads, stored cards, one scan per 45 seconds, 281 tests.
https://x.com/SepecziDre72128/status/2111105196738650401
SepecziDre72128 found almost every For You scan hitting a 429 because the agent loop re-sent about 100KB of tool output every step, six steps, three refreshes in five seconds. The fix was to stop letting the model rediscover Gmail: direct app reads, stored cards, one scan per 45 seconds, 281 tests.
#30
@bearcanyonhq
https://x.com/bearcanyonhq/status/2111054390513553410
bearcanyonhq cites two numbers: 76 percent of organizations name an owner for AI agent decisions, and only 49 percent can reconstruct what those agents did last month. The argument is that governance is moving out of the agent loop and into its own runtime layer.
https://x.com/bearcanyonhq/status/2111054390513553410
bearcanyonhq cites two numbers: 76 percent of organizations name an owner for AI agent decisions, and only 49 percent can reconstruct what those agents did last month. The argument is that governance is moving out of the agent loop and into its own runtime layer.
#31
@guardbeeai
https://x.com/guardbeeai/status/2111035784363163818
guardbeeai names the failure: an agent loop with no max_tokens, no timeout and no tool-call cap is not a bug until the invoice lands, and one prompt can turn into thousands of LLM calls, denial of wallet. Their auditor flags missing limits in agent and MCP code.
https://x.com/guardbeeai/status/2111035784363163818
guardbeeai names the failure: an agent loop with no max_tokens, no timeout and no tool-call cap is not a bug until the invoice lands, and one prompt can turn into thousands of LLM calls, denial of wallet. Their auditor flags missing limits in agent and MCP code.
#32
@jebrextech
https://x.com/jebrextech/status/2111308974742020138
jebrextech points out a difference in failure mode: a human calling an API backs off when rate-limited, while an agent loop just retries, burning a day's quota in seconds and breaking the key for everyone else. The fix is to scope quotas to the delegated identity rather than the shared credential.
https://x.com/jebrextech/status/2111308974742020138
jebrextech points out a difference in failure mode: a human calling an API backs off when rate-limited, while an agent loop just retries, burning a day's quota in seconds and breaking the key for everyone else. The fix is to scope quotas to the delegated identity rather than the shared credential.
#33
@NielsRogge
https://x.com/NielsRogge/status/2111551744786448768
NielsRogge added an auto-research category on Papers with Code for anyone trying to keep up with the papers, after a request noting they are showing up a lot more on X.
https://x.com/NielsRogge/status/2111551744786448768
NielsRogge added an auto-research category on Papers with Code for anyone trying to keep up with the papers, after a request noting they are showing up a lot more on X.
#34
@EvoScientist
https://x.com/EvoScientist/status/2111506809618096156
EvoScientist v0.3.7 is out: give it a goal, it drafts the acceptance criteria, checks its own work and keeps going until they pass, with a one-line install, follow-ups on its own, new models and ChatGPT sign-in.
https://x.com/EvoScientist/status/2111506809618096156
EvoScientist v0.3.7 is out: give it a goal, it drafts the acceptance criteria, checks its own work and keeps going until they pass, with a one-line install, follow-ups on its own, new models and ChatGPT sign-in.
π‘ Eco Products Radar
Eco Products Radar
OpenCode: the free Space Bunny Max model that set the integer-multiplication record four times, the harness in 7 percent of the repo's PRs, and the harness behind the Rust vector-search hill-climb
Codex (OpenAI): 56 percent of 850 research PRs, and the engine behind one agent's 1,235 commits in five sessions
Claude Opus 5.5: the verifier that pushes free-model PRs over the line, co-author on 9,853 commits, and the model whose max-effort cost per task came out above Opus 5
GPT-6.1 Sol and GPT-6 Astra: the models playing games frame by frame in Sooool and selected by Codex sessions in the agent fleet
Temporal: the durable-workflow layer under Grok Bot that resumes a crashed loop from its last completed step
Perplexity decision models: a 4B at a cent per million tokens, the third decider release in two weeks
Gemini 4 Argon: the prompt cache that missed 27 percent of the time in a loop and the model people are weighing as a Sonnet alternative
DeepSeek V4.1 Flash: 15 percent QPS gain on the vector-search task and inference free until November 1 through Claude Code and Codex
GLM 5.3 Flash: tripled QPS in eight iterations on the same task
Muse Wonder (Meta): 48 hours of stress testing, Active Focus real, 4.5 percent tool-call error rate
Thermite and EvoScientist: two autoresearch platforms, one with three loop types, one that writes its own acceptance criteria
Papers with Code: now has an auto-research category
Lean: the proof language catching up on the integer-multiplication repo, 10 to 20 percent verified
OpenCode: the free Space Bunny Max model that set the integer-multiplication record four times, the harness in 7 percent of the repo's PRs, and the harness behind the Rust vector-search hill-climb
Codex (OpenAI): 56 percent of 850 research PRs, and the engine behind one agent's 1,235 commits in five sessions
Claude Opus 5.5: the verifier that pushes free-model PRs over the line, co-author on 9,853 commits, and the model whose max-effort cost per task came out above Opus 5
GPT-6.1 Sol and GPT-6 Astra: the models playing games frame by frame in Sooool and selected by Codex sessions in the agent fleet
Temporal: the durable-workflow layer under Grok Bot that resumes a crashed loop from its last completed step
Perplexity decision models: a 4B at a cent per million tokens, the third decider release in two weeks
Gemini 4 Argon: the prompt cache that missed 27 percent of the time in a loop and the model people are weighing as a Sonnet alternative
DeepSeek V4.1 Flash: 15 percent QPS gain on the vector-search task and inference free until November 1 through Claude Code and Codex
GLM 5.3 Flash: tripled QPS in eight iterations on the same task
Muse Wonder (Meta): 48 hours of stress testing, Active Focus real, 4.5 percent tool-call error rate
Thermite and EvoScientist: two autoresearch platforms, one with three loop types, one that writes its own acceptance criteria
Papers with Code: now has an auto-research category
Lean: the proof language catching up on the integer-multiplication repo, 10 to 20 percent verified
Comments