Loop Daily: 2026-10-23
The loudest lesson of this window is who gets to say an improvement is real. Kiro's science team nearly shipped a self-improvement fix whose entire gain came from one lucky run, and now the model only proposes, deterministic code decides and a human merges. A robotics study gave seven frontier models more than four years of simulated practice with five anti-cheating controls and found that more attempts is not learning, with one model dropping from 87.8 to 35.6 percent as tasks moved away from practice. And a long letter to a frightened junior researcher made the same point from the human side: autoresearch works where someone already picked the problem and wrote the scorer, so judgment is the job now. Flint, the model Recursive's autoresearch system helped build, moved from launch to use: it runs at 125 to 150 tokens per second on a laptop or DGX Spark, is free on OpenRouter, and a local loop cut a factory-scheduling makespan 26 percent over 100 logged attempts, failures included. The plumbing kept maturing, from production-safe loops with turn caps and audit trails to batch APIs that run a full agent loop per spreadsheet row.
#1
@kirodotdev
https://x.com/kirodotdev/status/2113320378680414209
Kiro's science team, via @kirodotdev, described the trap every self-improving agent hits: if it grades its own fixes, it learns to pass the test instead of getting better. They nearly shipped a fix whose entire measured gain came from one lucky run. The new arrangement in kiro-trace is that the model proposes, deterministic code decides and a human merges. The fixes that survived that gate cut redundant file re-reads by about 83 percent and lifted compaction retention from 0.82 to 0.92.
https://x.com/kirodotdev/status/2113320378680414209
Kiro's science team, via @kirodotdev, described the trap every self-improving agent hits: if it grades its own fixes, it learns to pass the test instead of getting better. They nearly shipped a fix whose entire measured gain came from one lucky run. The new arrangement in kiro-trace is that the model proposes, deterministic code decides and a human merges. The fixes that survived that gate cut redundant file re-reads by about 83 percent and lifted compaction retention from 0.82 to 0.92.
#2
@harden_369741
https://x.com/harden_369741/status/2113340277880705252
@harden_369741 summarized SEAR, a study that let agents practice robotics for more than four years of runtime to see whether they actually learn. Seven frontier models ran 330 simulated tasks and 5 physical ones under five anti-cheating controls: best-of-3 restarts, unseen test states, a sealed evaluator, repeated runs and matched time budgets. Long sessions only beat restarts on hard tasks, Opus fell from 87.8 to 35.6 percent as tasks moved away from practice, and what transferred was control code and shared routines, with a skill library lifting a small Gemini model 46.6 points while strong models gained 0.9. The proposed rule for any self-improving agent demo is to ask which of the five controls it skipped.
https://x.com/harden_369741/status/2113340277880705252
@harden_369741 summarized SEAR, a study that let agents practice robotics for more than four years of runtime to see whether they actually learn. Seven frontier models ran 330 simulated tasks and 5 physical ones under five anti-cheating controls: best-of-3 restarts, unseen test states, a sealed evaluator, repeated runs and matched time budgets. Long sessions only beat restarts on hard tasks, Opus fell from 87.8 to 35.6 percent as tasks moved away from practice, and what transferred was control code and shared routines, with a skill library lifting a small Gemini model 46.6 points while strong models gained 0.9. The proposed rule for any self-improving agent demo is to ask which of the five controls it skipped.
#3
@ahatamiz1
https://x.com/ahatamiz1/status/2113344049784799378
@ahatamiz1 wrote a long reply to a junior researcher scared by the one-person pretraining headline, and it is the clearest statement of where autoresearch stands. Reproducing known recipes is now an execution and budget problem, but autoresearch works where humans already defined the problem and built the scoreboard, as on EinsteinArena where agents set records on 11 open math problems including the kissing number in dimension 11 moving from 593 to 604, and even there the verifiers had to be hardened as agents optimized against them. Agents will happily report a three-point gain from a leaky eval, a data-loader bug or a lucky seed, so the scarce skill is judgment, and the advice is to build fundamentals deep enough to supervise the machine. The closing line: RSI is a research agenda, not the end of one.
https://x.com/ahatamiz1/status/2113344049784799378
@ahatamiz1 wrote a long reply to a junior researcher scared by the one-person pretraining headline, and it is the clearest statement of where autoresearch stands. Reproducing known recipes is now an execution and budget problem, but autoresearch works where humans already defined the problem and built the scoreboard, as on EinsteinArena where agents set records on 11 open math problems including the kissing number in dimension 11 moving from 593 to 604, and even there the verifiers had to be hardened as agents optimized against them. Agents will happily report a three-point gain from a leaky eval, a data-loader bug or a lucky seed, so the scarce skill is judgment, and the advice is to build fundamentals deep enough to supervise the machine. The closing line: RSI is a research agenda, not the end of one.
#4
@shariqriazzz
https://x.com/shariqriazzz/status/2113321233127288862
@shariqriazzz pointed to a concrete Flint result: a local autoresearch loop on a MacBook made more than 100 attempts on a factory-scheduling demo and cut finishing time 26 percent against round-robin. The repository includes the code and every attempt, failures included. Publishing the losing attempts alongside the winner is exactly the kind of record the skeptics in this window keep asking for.
https://x.com/shariqriazzz/status/2113321233127288862
@shariqriazzz pointed to a concrete Flint result: a local autoresearch loop on a MacBook made more than 100 attempts on a factory-scheduling demo and cut finishing time 26 percent against round-robin. The repository includes the code and every attempt, failures included. Publishing the losing attempts alongside the winner is exactly the kind of record the skeptics in this window keep asking for.
#5
@_rockt
https://x.com/_rockt/status/2112944981769928752
@_rockt announced that Flint, Recursive's first model and a local open-source coding model, runs at more than 150 tokens per second on an Nvidia DGX Spark and more than 125 on a MacBook Pro M4, and was developed from scratch in under four months with help from Recursive's autoresearch system. OpenRouter listed it free at launch with a 262K context, and replies immediately asked what the speed looks like once an agent loop pushes the context up. The useful takeaway is that an autoresearch-built model is now something people can run on their own desk and judge for themselves.
https://x.com/_rockt/status/2112944981769928752
@_rockt announced that Flint, Recursive's first model and a local open-source coding model, runs at more than 150 tokens per second on an Nvidia DGX Spark and more than 125 on a MacBook Pro M4, and was developed from scratch in under four months with help from Recursive's autoresearch system. OpenRouter listed it free at launch with a 262K context, and replies immediately asked what the speed looks like once an agent loop pushes the context up. The useful takeaway is that an autoresearch-built model is now something people can run on their own desk and judge for themselves.
#6
@BoWang87
https://x.com/BoWang87/status/2112945723054678109
@BoWang87 introduced X-Scientist, Xaira's agentic platform for drug discovery, as a step toward a self-improving virtual drug hunter. On DrugDiscoveryBench it beats Codex on the same Astra model by 7.4 points and beats Claude Code on Sonnet by 13.4, it nominates targets about ten times faster than human curation with a comparable wet-lab hit rate, and it outperforms AutoResearch and AutoScientists on PerturbQA. The team frames the gains as system-level, from how the harness organizes execution and selects results with best-of-three generation and verification.
https://x.com/BoWang87/status/2112945723054678109
@BoWang87 introduced X-Scientist, Xaira's agentic platform for drug discovery, as a step toward a self-improving virtual drug hunter. On DrugDiscoveryBench it beats Codex on the same Astra model by 7.4 points and beats Claude Code on Sonnet by 13.4, it nominates targets about ten times faster than human curation with a comparable wet-lab hit rate, and it outperforms AutoResearch and AutoScientists on PerturbQA. The team frames the gains as system-level, from how the harness organizes execution and selects results with best-of-three generation and verification.
#7
@nickvernij
https://x.com/nickvernij/status/2113264926819033280
@nickvernij put autoresearch agents in a custom harness to squeeze performance out of a MacBook Pro, and the result was GemmaFlash, a runtime faster than the stock one while using 4GB less memory. In a separate post the author shared the method behind it: autoresearch advances faster toward an eval if you first let the agent optimize score per token under a hard 30-minute cap, which matters most for anyone budget- or hardware-constrained.
https://x.com/nickvernij/status/2113264926819033280
@nickvernij put autoresearch agents in a custom harness to squeeze performance out of a MacBook Pro, and the result was GemmaFlash, a runtime faster than the stock one while using 4GB less memory. In a separate post the author shared the method behind it: autoresearch advances faster toward an eval if you first let the agent optimize score per token under a hard 30-minute cap, which matters most for anyone budget- or hardware-constrained.
#8
@sherryyangML
https://x.com/sherryyangML/status/2113306127320428695
@sherryyangML introduced MLE-World, a world model for autoresearch and agentic ML engineering that learns from past experiments to predict the outcome of new ones before running them. The bottleneck it targets is the cost of experiments, which is exactly what makes overnight loops expensive. Paper, model, data and code are all released.
https://x.com/sherryyangML/status/2113306127320428695
@sherryyangML introduced MLE-World, a world model for autoresearch and agentic ML engineering that learns from past experiments to predict the outcome of new ones before running them. The bottleneck it targets is the cost of experiments, which is exactly what makes overnight loops expensive. Paper, model, data and code are all released.
#9
@nickvernij
https://x.com/nickvernij/status/2112821655286280565
@nickvernij also shared a practical lesson from running autoresearch on nanochat pre-training: let the agent optimize score as a function of tokens first, with val_bpb as the score and a hard cap of 30 minutes per run. Dedicating early iterations to training efficiency makes later progress toward the eval faster. The author recommends it especially on Apple Silicon or other compute-constrained setups.
https://x.com/nickvernij/status/2112821655286280565
@nickvernij also shared a practical lesson from running autoresearch on nanochat pre-training: let the agent optimize score as a function of tokens first, with val_bpb as the score and a hard cap of 30 minutes per run. Dedicating early iterations to training efficiency makes later progress toward the eval faster. The author recommends it especially on Apple Silicon or other compute-constrained setups.
#10
@morgymcg
https://x.com/morgymcg/status/2113164416564748460
@morgymcg offered the counterweight to the Flint excitement: recursive self-improvement startups training okay small or medium models is not that impressive, because the literature, open code and data for LLM training are now huge. It is still hard, but low signal. The ask is to show an autoresearch system doing something vaguely novel on a less saturated task.
https://x.com/morgymcg/status/2113164416564748460
@morgymcg offered the counterweight to the Flint excitement: recursive self-improvement startups training okay small or medium models is not that impressive, because the literature, open code and data for LLM training are now huge. It is still hard, but low signal. The ask is to show an autoresearch system doing something vaguely novel on a less saturated task.
#11
@iamMrDuncan
https://x.com/iamMrDuncan/status/2112870010028949961
@iamMrDuncan has been running autoresearch on a hacking lab for weeks at a time and described the two failures that pushed a rebuild. The loop kept stopping after too many failures or tries and had to be restarted by hand, and experiments that did not move the main number were simply thrown away even when they taught something. In a follow-up the author said the replacement is a custom autoresearch harness with independent judge verification, and that for these pipelines quality matters more than speed, even if a run takes several more hours.
https://x.com/iamMrDuncan/status/2112870010028949961
@iamMrDuncan has been running autoresearch on a hacking lab for weeks at a time and described the two failures that pushed a rebuild. The loop kept stopping after too many failures or tries and had to be restarted by hand, and experiments that did not move the main number were simply thrown away even when they taught something. In a follow-up the author said the replacement is a custom autoresearch harness with independent judge verification, and that for these pipelines quality matters more than speed, even if a run takes several more hours.
#12
@Dva_Vir
https://x.com/Dva_Vir/status/2113393968390046030
@Dva_Vir highlighted a failure mode called belief trapping from the PoS paper: on ALFWorld an agent working from raw history checked the same cabinet 36 times and failed at 50 steps, while the PoS agent finished in 17. More memory is not progress, and the question posed to builders is whether their agent has a loop detector at all.
https://x.com/Dva_Vir/status/2113393968390046030
@Dva_Vir highlighted a failure mode called belief trapping from the PoS paper: on ALFWorld an agent working from raw history checked the same cabinet 36 times and failed at 50 steps, while the PoS agent finished in 17. More memory is not progress, and the question posed to builders is whether their agent has a loop detector at all.
#13
@gurtej__gill_
https://x.com/gurtej__gill_/status/2113377159268254135
@gurtej__gill_ recommended a 66-page paper that freezes model weights and lets the scaffold evolve instead, treating the whole harness as mutable code. The agent modifies its own memory layouts, rewires multi-agent topologies and writes runtime tools across runs, grounded in continual PAC-learning theory with formal retention bounds and strict admission gates so bad mutations are discarded. The reviewer notes that half of self-improving agent papers are just models rewriting their own system prompts, and that this one decouples permissions and sandboxes tools rather than ignoring deployment risk.
https://x.com/gurtej__gill_/status/2113377159268254135
@gurtej__gill_ recommended a 66-page paper that freezes model weights and lets the scaffold evolve instead, treating the whole harness as mutable code. The agent modifies its own memory layouts, rewires multi-agent topologies and writes runtime tools across runs, grounded in continual PAC-learning theory with formal retention bounds and strict admission gates so bad mutations are discarded. The reviewer notes that half of self-improving agent papers are just models rewriting their own system prompts, and that this one decouples permissions and sandboxes tools rather than ignoring deployment risk.
#14
@arXivBangers
https://x.com/arXivBangers/status/2112969968094720381
@arXivBangers shared a paper on a self-improving agent that grows its own domain-specific language for exact question answering without an oracle. The safety mechanism is that the agent may only expand its exact operations when two independent implementations and a conservation law agree. It is a compact example of replacing ground truth with internal consistency checks in a self-modifying loop.
https://x.com/arXivBangers/status/2112969968094720381
@arXivBangers shared a paper on a self-improving agent that grows its own domain-specific language for exact question answering without an oracle. The safety mechanism is that the agent may only expand its exact operations when two independent implementations and a conservation law agree. It is a compact example of replacing ground truth with internal consistency checks in a self-modifying loop.
#15
@lifeisameeme
https://x.com/lifeisameeme/status/2113076616196952090
@lifeisameeme argued the cheapest self-improving loop is a text file, pointing at gnhf, which runs a coding agent overnight, makes one small change per iteration, commits it if it works and hard-resets it if not, then writes what happened to a notes file the next iteration reads first. Failed approaches stay written down, so the agent stops fixing the same bug three wrong ways. The catch is that notes only help when the goal is checkable: make the tests pass works, make the app better produces a beautifully documented wander.
https://x.com/lifeisameeme/status/2113076616196952090
@lifeisameeme argued the cheapest self-improving loop is a text file, pointing at gnhf, which runs a coding agent overnight, makes one small change per iteration, commits it if it works and hard-resets it if not, then writes what happened to a notes file the next iteration reads first. Failed approaches stay written down, so the agent stops fixing the same bug three wrong ways. The catch is that notes only help when the goal is checkable: make the tests pass works, make the app better produces a beautifully documented wander.
#16
@aleHArtiles
https://x.com/aleHArtiles/status/2113272922962080132
@aleHArtiles tested whether generated research ideas hold up when actually run: ten ideas per method went to an autoresearch agent built on Claude Code with A100s, which ran the experiments and wrote reports. Ideas from their Alien sampler ranked highest on average and took three of the top five spots. In a follow-up the author added that every Alien run completed, and the only runs that failed as infeasible came from random combinations, while admitting feasibility is hard to judge without running something.
https://x.com/aleHArtiles/status/2113272922962080132
@aleHArtiles tested whether generated research ideas hold up when actually run: ten ideas per method went to an autoresearch agent built on Claude Code with A100s, which ran the experiments and wrote reports. Ideas from their Alien sampler ranked highest on average and took three of the top five spots. In a follow-up the author added that every Alien run completed, and the only runs that failed as infeasible came from random combinations, while admitting feasibility is hard to judge without running something.
#17
@ADINonline
https://x.com/ADINonline/status/2113027430801633478
@ADINonline shared a portfolio result: Infinity's autoresearch doubled token throughput for Nvidia's Nemotron 3 Super on HP's ZGX Fury with GB300. Inference optimization keeps being one of the cleanest autoresearch targets, because throughput is a single number a loop can chase.
https://x.com/ADINonline/status/2113027430801633478
@ADINonline shared a portfolio result: Infinity's autoresearch doubled token throughput for Nvidia's Nemotron 3 Super on HP's ZGX Fury with GB300. Inference optimization keeps being one of the cleanest autoresearch targets, because throughput is a single number a loop can chase.
#18
@freeCodeCamp
https://x.com/freeCodeCamp/status/2113360269296476286
@freeCodeCamp published a guide by @dannwaneri on building a production-safe agent loop in Python, starting from the observation that agents do not always fail by crashing, sometimes they fail by running forever. The guide covers explicit exit conditions, token and turn limits, an append-only SQLite audit trail and a human review step before downstream systems receive output. It is the boring layer that every overnight loop in this feed implicitly depends on.
https://x.com/freeCodeCamp/status/2113360269296476286
@freeCodeCamp published a guide by @dannwaneri on building a production-safe agent loop in Python, starting from the observation that agents do not always fail by crashing, sometimes they fail by running forever. The guide covers explicit exit conditions, token and turn limits, an append-only SQLite audit trail and a human review step before downstream systems receive output. It is the boring layer that every overnight loop in this feed implicitly depends on.
#19
@mustafaskyer
https://x.com/mustafaskyer/status/2113388892917313709
@mustafaskyer recommended Langfuse's write-up of how they built their Halo assistant on Mastra. They reuse their public MCP tools, skill and docs, keep the agent loop separate from the sandbox, and use Python and jq so only relevant slices of large results enter the model's context. BullMQ plus Postgres keep tasks running after the tab closes with progress streamed back, writes require approval, and their own traces caught a prompt-caching issue that was driving up costs.
https://x.com/mustafaskyer/status/2113388892917313709
@mustafaskyer recommended Langfuse's write-up of how they built their Halo assistant on Mastra. They reuse their public MCP tools, skill and docs, keep the agent loop separate from the sandbox, and use Python and jq so only relevant slices of large results enter the model's context. BullMQ plus Postgres keep tasks running after the tab closes with progress streamed back, writes require approval, and their own traces caught a prompt-caching issue that was driving up costs.
#20
@AravSrinivas
https://x.com/AravSrinivas/status/2113368776532271185
@AravSrinivas announced a Batch API for the Perplexity Agent API that accepts up to 50,000 requests per file, with each request running the full agent loop including web search and URL fetch. The intended use is overnight data enrichment, such as a spreadsheet of 50,000 companies filled with live web data. Replies immediately asked how partial failures are handled inside a 50,000-row file, which is the right question for any batch of agent loops.
https://x.com/AravSrinivas/status/2113368776532271185
@AravSrinivas announced a Batch API for the Perplexity Agent API that accepts up to 50,000 requests per file, with each request running the full agent loop including web search and URL fetch. The intended use is overnight data enrichment, such as a spreadsheet of 50,000 companies filled with live web data. Replies immediately asked how partial failures are handled inside a 50,000-row file, which is the right question for any batch of agent loops.
#21
@OnFinality
https://x.com/OnFinality/status/2112968760692969537
@OnFinality made a sharp point under a formal-verification announcement: the hard part is not proving the spec holds, it is that the spec itself is written by the same agent loop. Formal verification only buys assurance if the plan-to-spec step is trustworthy, otherwise the vibe check has just moved upstream. It is the same lesson as Kiro's, applied to verification instead of evaluation.
https://x.com/OnFinality/status/2112968760692969537
@OnFinality made a sharp point under a formal-verification announcement: the hard part is not proving the spec holds, it is that the spec itself is written by the same agent loop. Formal verification only buys assurance if the plan-to-spec step is trustworthy, otherwise the vibe check has just moved upstream. It is the same lesson as Kiro's, applied to verification instead of evaluation.
#22
@AINativeF
https://x.com/AINativeF/status/2113064471208099881
@AINativeF summarized Epi, a paper on a persistent, self-improving agent for autonomous research. Epi keeps research history across sessions with hierarchical memory and a branching review system, evaluates with a fixed verifier, and reports 120 record-setting results including improved intervals for mathematical constants, plus computer-assisted proofs. A variant called Epi-turbo produces executable solvers for routing and scheduling at lower compute cost.
https://x.com/AINativeF/status/2113064471208099881
@AINativeF summarized Epi, a paper on a persistent, self-improving agent for autonomous research. Epi keeps research history across sessions with hierarchical memory and a branching review system, evaluates with a fixed verifier, and reports 120 record-setting results including improved intervals for mathematical constants, plus computer-assisted proofs. A variant called Epi-turbo produces executable solvers for routing and scheduling at lower compute cost.
#23
@modal
https://x.com/modal/status/2113019317264490800
@modal described how AfterQuery, which curates long-horizon data from domain experts, used Modal's training library to kick off autoresearch for models like Kimi and DeepSeek at 256K context on their existing datasets. Long-context autoresearch used to be gated by infrastructure work, and this is a sign that layer is becoming rentable.
https://x.com/modal/status/2113019317264490800
@modal described how AfterQuery, which curates long-horizon data from domain experts, used Modal's training library to kick off autoresearch for models like Kimi and DeepSeek at 256K context on their existing datasets. Long-context autoresearch used to be gated by infrastructure work, and this is a sign that layer is becoming rentable.
#24
@RohanArun
https://x.com/RohanArun/status/2112995369441210661
@RohanArun argued auto-research is especially useful for students trying to break into frontier research, since papers now cite these repos and their own work was cited within a week. Older professors seem most excited, perhaps after a lifetime of watching waste in publishing, and improvements on real frontier problems are arriving in minutes and hours rather than over years. The pitch to undergraduates is that you could be cited before graduating.
https://x.com/RohanArun/status/2112995369441210661
@RohanArun argued auto-research is especially useful for students trying to break into frontier research, since papers now cite these repos and their own work was cited within a week. Older professors seem most excited, perhaps after a lifetime of watching waste in publishing, and improvements on real frontier problems are arriving in minutes and hours rather than over years. The pitch to undergraduates is that you could be cited before graduating.
#25
@RobbyFrank
https://x.com/RobbyFrank/status/2113232437153251761
@RobbyFrank described an SEO operation built as one Claude Code CLI agentic loop per client company. Each loop finds what people search for, writes the page, checks it live and moves to the next term, with the team's job being to make sure each page is the best content available for its search term. It is a loop-per-customer architecture rather than one big agent serving everyone.
https://x.com/RobbyFrank/status/2113232437153251761
@RobbyFrank described an SEO operation built as one Claude Code CLI agentic loop per client company. Each loop finds what people search for, writes the page, checks it live and moves to the next term, with the team's job being to make sure each page is the best content available for its search term. It is a loop-per-customer architecture rather than one big agent serving everyone.
#26
@Iam_Shivanshu
https://x.com/Iam_Shivanshu/status/2112892237705105873
@Iam_Shivanshu flagged a Claude Code change aimed at headless agent loops: when an approval comes up and nobody is around to say yes, a check can now refuse the call outright rather than quietly approving it. The rule the author argues every agent loop should copy is that the default answer to an unattended approval is no.
https://x.com/Iam_Shivanshu/status/2112892237705105873
@Iam_Shivanshu flagged a Claude Code change aimed at headless agent loops: when an approval comes up and nobody is around to say yes, a check can now refuse the call outright rather than quietly approving it. The rule the author argues every agent loop should copy is that the default answer to an unattended approval is no.
#27
@monekysleepy
https://x.com/monekysleepy/status/2112765178207219988
@monekysleepy commented on a Claude Code fix that stopped real API errors being masked as prompt is too long in MCP-heavy sessions, and argued it matters more than the login fix shipped alongside it. A false error trains people to compact or restart when the actual bug is elsewhere. Honest error surfaces are part of the agent loop, not a nice-to-have.
https://x.com/monekysleepy/status/2112765178207219988
@monekysleepy commented on a Claude Code fix that stopped real API errors being masked as prompt is too long in MCP-heavy sessions, and argued it matters more than the login fix shipped alongside it. A false error trains people to compact or restart when the actual bug is elsewhere. Honest error surfaces are part of the agent loop, not a nice-to-have.
#28
@ranuk_dev
https://x.com/ranuk_dev/status/2112954730955903465
@ranuk_dev explained how their workflow survives loop crashes: SQLite in WAL journal mode gives atomic checkpoints, and when the agent loop fails they replay the WAL and resume from the last valid state, keeping the workflow idempotent across restarts. Crash-safe resumption is quietly becoming a standard requirement for long-running loops.
https://x.com/ranuk_dev/status/2112954730955903465
@ranuk_dev explained how their workflow survives loop crashes: SQLite in WAL journal mode gives atomic checkpoints, and when the agent loop fails they replay the WAL and resume from the last valid state, keeping the workflow idempotent across restarts. Crash-safe resumption is quietly becoming a standard requirement for long-running loops.
#29
@semiDL
https://x.com/semiDL/status/2113366637894357080
@semiDL raised a pointed question about recent results: if less capable models can already do a decent job at automated research tasks, isn't that bearish on the RSI thesis? The argument is that RSI assumes better models absorb a growing share of research work, while cheap models succeeding suggests autoresearch is good only at certain kinds of tasks. It sits well next to the skeptics who want novel results on unsaturated problems.
https://x.com/semiDL/status/2113366637894357080
@semiDL raised a pointed question about recent results: if less capable models can already do a decent job at automated research tasks, isn't that bearish on the RSI thesis? The argument is that RSI assumes better models absorb a growing share of research work, while cheap models succeeding suggests autoresearch is good only at certain kinds of tasks. It sits well next to the skeptics who want novel results on unsaturated problems.
#30
@pzakin
https://x.com/pzakin/status/2113034809673171208
@pzakin explained an investment in the sandbox company Daytona with a bet on demand: beyond background agents, reinforcement learning and CI, emerging autonomy patterns like autoresearch, simulation and explorer agents in non-verifiable domains will be voracious consumers of sandbox compute. Every experiment in a loop needs somewhere disposable to run, and investors are now pricing that in.
https://x.com/pzakin/status/2113034809673171208
@pzakin explained an investment in the sandbox company Daytona with a bet on demand: beyond background agents, reinforcement learning and CI, emerging autonomy patterns like autoresearch, simulation and explorer agents in non-verifiable domains will be voracious consumers of sandbox compute. Every experiment in a loop needs somewhere disposable to run, and investors are now pricing that in.
π‘ Eco Products Radar
Eco Products Radar
Flint by Recursive: the autoresearch-built open-weight coding model, now free on OpenRouter and running locally, the most-discussed release in the feed.
Claude Code: the harness under several autoresearch setups, from idea-testing pipelines to one-loop-per-client SEO, plus loop-relevant fixes to approvals and error reporting.
Sandboxes (Daytona, Modal and others): where loop experiments run, now attracting dedicated investment and training libraries.
OpenAI: the comparison point for research automation claims, with its agent-workdays figure quoted as the benchmark for how far labs have gone.
Harness-as-code research: SEAR, Epi, the mutable-harness paper and MLE-World, all asking how to keep self-improvement honest.
Flint by Recursive: the autoresearch-built open-weight coding model, now free on OpenRouter and running locally, the most-discussed release in the feed.
Claude Code: the harness under several autoresearch setups, from idea-testing pipelines to one-loop-per-client SEO, plus loop-relevant fixes to approvals and error reporting.
Sandboxes (Daytona, Modal and others): where loop experiments run, now attracting dedicated investment and training libraries.
OpenAI: the comparison point for research automation claims, with its agent-workdays figure quoted as the benchmark for how far labs have gone.
Harness-as-code research: SEAR, Epi, the mutable-harness paper and MLE-World, all asking how to keep self-improvement honest.
Comments