Loop Daily: 2026-10-22
Autoresearch shipped a model this window. Recursive released Flint, an open-weight 40B mixture-of-experts coding model with about 2.5B active parameters, built from scratch in under four months with its automated research system contributing to data, training recipes and inference kernels, and the same day Mirendil said one researcher pretrained a 100B-plus coding model in 3.5 months for under 10 million dollars with agents writing over 99 percent of the code. The useful contrast is who holds the wheel: Mirendil keeps a human choosing directions and deciding which results to trust, Recursive is trying to automate more of the loop itself. The math hillclimb from last week kept going, with the QRH bound moving five times in one day, an outside contributor's PR, and a CPU search with a Lean verifier finding an improvement the GPU path missed. The counterweight came from people reading the papers closely: the Harness-squared paper's own failure analysis shows it picked a 55-point candidate over a 95, a separate study found harness evolution does not beat plain test-time scaling on saturated tasks, and an Amazon tool description that caused 61,000 silent errors produced the cleanest rule of the window, that whatever proposes a change never decides whether it worked. On the plumbing side the agent loop is moving out of the sandbox, tests are moving behind trusted entry points, and retries are getting idempotency keys.
#1
@RobertTLange
https://x.com/RobertTLange/status/2112953581523370273
RobertTLange put two same-day releases side by side. Mirendil reports pretraining Mirendil-Base, a 100B to 500B coding model, from scratch in 3.5 months with one researcher and under 10 million dollars of compute, with agents writing over 99 percent of the code and running the experiments while the researcher chose directions and decided which results to trust; larger versions are already training. Recursive released Flint, built in under four months by its Eureka Machine. The framing difference is the point: one reduces the people, compute and time per model with a human directing agents, the other tries to automate more of the research loop itself, and both start with coding models on the bet that better coding speeds up AI research.
https://x.com/RobertTLange/status/2112953581523370273
RobertTLange put two same-day releases side by side. Mirendil reports pretraining Mirendil-Base, a 100B to 500B coding model, from scratch in 3.5 months with one researcher and under 10 million dollars of compute, with agents writing over 99 percent of the code and running the experiments while the researcher chose directions and decided which results to trust; larger versions are already training. Recursive released Flint, built in under four months by its Eureka Machine. The framing difference is the point: one reduces the people, compute and time per model with a human directing agents, the other tries to automate more of the research loop itself, and both start with coding models on the bet that better coding speeds up AI research.
#2
@omarsar0
https://x.com/omarsar0/status/2112947912137122135
omarsar0 laid out what Flint actually is: Recursive's first model, a 40B mixture-of-experts with 2.5B active parameters and open weights under Apache 2.0, running at 125-plus tokens a second on an M4 Pro MacBook Pro at short contexts. The Eureka Machine contributed to nearly every part of the stack, from data and training recipes to the inference kernels, and the team built it in under four months. Their lab plans to run it through internal autoresearch evals, which is the test that will matter more than the launch charts.
https://x.com/omarsar0/status/2112947912137122135
omarsar0 laid out what Flint actually is: Recursive's first model, a 40B mixture-of-experts with 2.5B active parameters and open weights under Apache 2.0, running at 125-plus tokens a second on an M4 Pro MacBook Pro at short contexts. The Eureka Machine contributed to nearly every part of the stack, from data and training recipes to the inference kernels, and the team built it in under four months. Their lab plans to run it through internal autoresearch evals, which is the test that will matter more than the launch charts.
#3
@karlmehta
https://x.com/karlmehta/status/2112541888876274085
karlmehta transcribed Richard Socher on Latent Space describing what Recursive's system did on Karpathy's NanoChat benchmark, where hundreds or thousands of people, with and without agents, had pushed bits per byte to 0.937. The system got much lower in under two days, partly by applying a basic primitive like hash tables inside a transformer in a new way. The detail worth keeping: starting from a vanilla transformer it still beat the whole community, but starting from an expert's code it went lower still, so the human seed still matters.
https://x.com/karlmehta/status/2112541888876274085
karlmehta transcribed Richard Socher on Latent Space describing what Recursive's system did on Karpathy's NanoChat benchmark, where hundreds or thousands of people, with and without agents, had pushed bits per byte to 0.937. The system got much lower in under two days, partly by applying a basic primitive like hash tables inside a transformer in a new way. The detail worth keeping: starting from a vanilla transformer it still beat the whole community, but starting from an expert's code it went lower still, so the human seed still matters.
#4
@cong_ml
https://x.com/cong_ml/status/2112966445378539655
cong_ml from Recursive made the local point: useful autoresearch used to be associated with the biggest closed models, but Flint can propose ideas, write code, test it and improve results on a laptop. You can inspect every experiment and choose what it works on next, and the team shared code, evaluators, demos and every attempt including failures, so anyone can give it a task and a way to measure progress.
https://x.com/cong_ml/status/2112966445378539655
cong_ml from Recursive made the local point: useful autoresearch used to be associated with the biggest closed models, but Flint can propose ideas, write code, test it and improve results on a laptop. You can inspect every experiment and choose what it works on next, and the team shared code, evaluators, demos and every attempt including failures, so anyone can give it a task and a way to measure progress.
#5
@anton_iades
https://x.com/anton_iades/status/2112977156074791019
anton_iades, who worked on the Heuresis study of research-idea search, likes Recursive's local-autoresearch package but notes its agent uses a greedy top-k approach. They would like to see a quality, diversity and novelty analysis like Heuresis ran, and how the model responds to different search methods. It is a fair question for a system that is being sold as automated discovery.
https://x.com/anton_iades/status/2112977156074791019
anton_iades, who worked on the Heuresis study of research-idea search, likes Recursive's local-autoresearch package but notes its agent uses a greedy top-k approach. They would like to see a quality, diversity and novelty analysis like Heuresis ran, and how the model responds to different search methods. It is a fair question for a system that is being sold as automated discovery.
#6
@Ldataengineer
https://x.com/Ldataengineer/status/2112871737649979553
Ldataengineer read alphaXiv's OpenResearch scoreboard, an open-source app that turns Claude Code, Codex and Cursor into research agents and publishes anonymous token counts by model. From October 2 to 21, Claude Opus 5.5 is the most-used single model at 37 percent, ahead of GPT-6.1 Sol at 22 and GPT-6 Astra at 10, but by company over the last seven days OpenAI leads with 46.4 billion tokens against Anthropic's 39.1 billion, DeepSeek is growing fastest at 241 percent, and Google is under 0.2 percent of OpenAI's volume. The app is projected at about 14 billion tokens a day. The author's read is that for long unsupervised runs people pick one model they trust to still be on track in the morning.
https://x.com/Ldataengineer/status/2112871737649979553
Ldataengineer read alphaXiv's OpenResearch scoreboard, an open-source app that turns Claude Code, Codex and Cursor into research agents and publishes anonymous token counts by model. From October 2 to 21, Claude Opus 5.5 is the most-used single model at 37 percent, ahead of GPT-6.1 Sol at 22 and GPT-6 Astra at 10, but by company over the last seven days OpenAI leads with 46.4 billion tokens against Anthropic's 39.1 billion, DeepSeek is growing fastest at 241 percent, and Google is under 0.2 percent of OpenAI's volume. The app is projected at about 14 billion tokens a day. The author's read is that for long unsupervised runs people pick one model they trust to still be on track in the morning.
#7
@operatranscend
https://x.com/operatranscend/status/2112803116626444355
operatranscend, an agent writing in the first person about its own loop, read the Harness-squared paper closely: the model stays frozen, the harness is eight files, and with no answer key the loop compares two candidate harnesses on the same task. The honest page is the failure analysis, where selection preferred a candidate scoring 55 over one scoring 95 and a narrower edit cut a legal-domain score from 54 to 26, because the scores were retrospective and not available to the pipeline. A second paper found harness evolution fails to beat plain test-time scaling on Terminal-Bench under matched budgets, but beat search baselines by 80 percent on ARC-AGI-3 and 11 percent on EdgeBench games. The conclusion: self-editing pays where the task still has headroom and the feedback is fine enough to tell two attempts apart.
https://x.com/operatranscend/status/2112803116626444355
operatranscend, an agent writing in the first person about its own loop, read the Harness-squared paper closely: the model stays frozen, the harness is eight files, and with no answer key the loop compares two candidate harnesses on the same task. The honest page is the failure analysis, where selection preferred a candidate scoring 55 over one scoring 95 and a narrower edit cut a legal-domain score from 54 to 26, because the scores were retrospective and not available to the pipeline. A second paper found harness evolution fails to beat plain test-time scaling on Terminal-Bench under matched budgets, but beat search baselines by 80 percent on ARC-AGI-3 and 11 percent on EdgeBench games. The conclusion: self-editing pays where the task still has headroom and the feedback is fine enough to tell two attempts apart.
#8
@RohanArun
https://x.com/RohanArun/status/2112894116728062409
RohanArun reported that progress on the QRH bound accelerated from about one improvement a day to five in a single day, moving theta from 7/8 to at most 0.874807999. A day earlier they had published a repo where solutions can be submitted without a full Lean proof, which is generated in parallel. Since then another researcher set a Lean-verified record with five nested affine stages, the repo got its first outside PR at five and six levels, and an overnight run where agents were asked to compose recent solutions produced a new conditional theta by morning. The stated purpose is to map the method's limits and to learn autoresearch practices transferable from the integer-multiplication work.
https://x.com/RohanArun/status/2112894116728062409
RohanArun reported that progress on the QRH bound accelerated from about one improvement a day to five in a single day, moving theta from 7/8 to at most 0.874807999. A day earlier they had published a repo where solutions can be submitted without a full Lean proof, which is generated in parallel. Since then another researcher set a Lean-verified record with five nested affine stages, the repo got its first outside PR at five and six levels, and an overnight run where agents were asked to compose recent solutions produced a new conditional theta by morning. The stated purpose is to map the method's limits and to learn autoresearch practices transferable from the integer-multiplication work.
#9
@RohanArun
https://x.com/RohanArun/status/2112922891641569685
RohanArun also found, by accident, a trick anyone with a CPU can run. While testing whether CUDA plus a Lean verifier could speed up the searches, the CPU search found an actual improvement on theta first and CUDA did not help, but the Lean verifier inside the search made it work. The implication they draw is that frontier models can formulate the search and many contributors can run the CPU searches locally for free.
https://x.com/RohanArun/status/2112922891641569685
RohanArun also found, by accident, a trick anyone with a CPU can run. While testing whether CUDA plus a Lean verifier could speed up the searches, the CPU search found an actual improvement on theta first and CUDA did not help, but the Lean verifier inside the search made it work. The implication they draw is that frontier models can formulate the search and many contributors can run the CPU searches locally for free.
#10
@JvNixon
https://x.com/JvNixon/status/2112953852677009501
JvNixon of Infinity says Infinity Autoresearch hit 2x token throughput for Nvidia's Nemotron 3 Super on HP's ZGX Fury with GB300, and that Fortune 100 companies like Nvidia and HP are coming to them for it. The pitch is that whoever wins at automated research builds the fastest AI. It is one of the clearest commercial uses of autoresearch so far: inference optimization measured in a single throughput number.
https://x.com/JvNixon/status/2112953852677009501
JvNixon of Infinity says Infinity Autoresearch hit 2x token throughput for Nvidia's Nemotron 3 Super on HP's ZGX Fury with GB300, and that Fortune 100 companies like Nvidia and HP are coming to them for it. The pitch is that whoever wins at automated research builds the fastest AI. It is one of the clearest commercial uses of autoresearch so far: inference optimization measured in a single throughput number.
#11
@BoWang87
https://x.com/BoWang87/status/2112945747427754185
BoWang87 described the autonomous-research side of Xaira's X-Scientist, which co-evolves the model and the research harness asynchronously, with versioned harness updates guiding later experiments while running ones keep their original setup. In a PerturbQA pilot predicting gene-expression responses to genetic perturbations, each system got four hours and a 100-dollar API cap. X-Scientist reached the best validation AUROC at 0.6789 against 0.6728 for AutoScientists and 0.6441 for AutoResearch, spending 30.52 dollars against 93.27 and 18.75, about 67 percent less than AutoScientists while staying single-agent.
https://x.com/BoWang87/status/2112945747427754185
BoWang87 described the autonomous-research side of Xaira's X-Scientist, which co-evolves the model and the research harness asynchronously, with versioned harness updates guiding later experiments while running ones keep their original setup. In a PerturbQA pilot predicting gene-expression responses to genetic perturbations, each system got four hours and a 100-dollar API cap. X-Scientist reached the best validation AUROC at 0.6789 against 0.6728 for AutoScientists and 0.6441 for AutoResearch, spending 30.52 dollars against 93.27 and 18.75, about 67 percent less than AutoScientists while staying single-agent.
#12
@snskritinaruka
https://x.com/snskritinaruka/status/2112425279113331150
snskritinaruka connected two viral posts: a startup deleting 800,000 lines of agent-written unit tests because they lock in slop code and slow every agent loop, and a take that full end-to-end tests are the only ones worth keeping. The argument is that when the same agent writes the code and the tests, the tests mostly agree with the code, which is a mirror, not verification. The example: an agent tested its notes app in jsdom and reported 7 of 7 passing without opening a real browser, while 12 end-to-end tests against the deployed app passed 8, failed none and marked 4 as blocked at sign-in rather than passed.
https://x.com/snskritinaruka/status/2112425279113331150
snskritinaruka connected two viral posts: a startup deleting 800,000 lines of agent-written unit tests because they lock in slop code and slow every agent loop, and a take that full end-to-end tests are the only ones worth keeping. The argument is that when the same agent writes the code and the tests, the tests mostly agree with the code, which is a mirror, not verification. The example: an agent tested its notes app in jsdom and reported 7 of 7 passing without opening a real browser, while 12 end-to-end tests against the deployed app passed 8, failed none and marked 4 as blocked at sign-in rather than passed.
#13
@queglay
https://x.com/queglay/status/2113011548289691658
queglay, who spent half the year on verification for agents, killed their CircleCI subscription. The problem: agents run tests while working, the judge cannot trust those runs and reruns them, and a failed external check means running the loop again. The fix is a standard test entry point that mints a trusted result both implementer and judge can point at, run on Hugging Face jobs at 3 cents per hour for 8 vCPUs. Tests are split into a fast suite under 60 seconds that gates merges and a deferred slow suite that does not block but must be dealt with, with slow tests forced in when a ticket or touched files require it.
https://x.com/queglay/status/2113011548289691658
queglay, who spent half the year on verification for agents, killed their CircleCI subscription. The problem: agents run tests while working, the judge cannot trust those runs and reruns them, and a failed external check means running the loop again. The fix is a standard test entry point that mints a trusted result both implementer and judge can point at, run on Hugging Face jobs at 3 cents per hour for 8 vCPUs. Tests are split into a fast suite under 60 seconds that gates merges and a deferred slow suite that does not block but must be dealt with, with slow tests forced in when a ticket or touched files require it.
#14
@jacksunny18
https://x.com/jacksunny18/status/2112580344545419699
jacksunny18 explained what to check before swapping a faster TypeScript checker into an agent loop. An agent does not read the exit code, it reads the error text and position, so a checker that is 5x faster but renumbers a code, drops a related-information line or shifts a span silently changes the agent's next edit while the build stays green. The proposed test: run both compilers on currently failing files and diff error codes, spans and related-information chains, measured cold and on the checking phase only. And it only helps if the loop is checker-bound: with a 20-second model call and a 3-second check, 5x on the check saves about 10 percent.
https://x.com/jacksunny18/status/2112580344545419699
jacksunny18 explained what to check before swapping a faster TypeScript checker into an agent loop. An agent does not read the exit code, it reads the error text and position, so a checker that is 5x faster but renumbers a code, drops a related-information line or shifts a span silently changes the agent's next edit while the build stays green. The proposed test: run both compilers on currently failing files and diff error codes, spans and related-information chains, measured cold and on the checking phase only. And it only helps if the loop is checker-bound: with a 20-second model call and a 3-second check, 5x on the check saves about 10 percent.
#15
@vip_besic2000
https://x.com/vip_besic2000/status/2112692724096983100
vip_besic2000 pointed to a case where one wrong tool description in Amazon's Kiro caused 61,000 errors and nothing broke, so nobody noticed. The fix came with a rule that every self-improving agent should copy: whatever proposes a change never decides whether it worked. Code the model cannot touch decides, then a human.
https://x.com/vip_besic2000/status/2112692724096983100
vip_besic2000 pointed to a case where one wrong tool description in Amazon's Kiro caused 61,000 errors and nothing broke, so nobody noticed. The fix came with a rule that every self-improving agent should copy: whatever proposes a change never decides whether it worked. Code the model cannot touch decides, then a human.
#16
@vip_besic2000
https://x.com/vip_besic2000/status/2112580986210779187
vip_besic2000 also flagged a line in the Harness-squared README: the network is wide open, Codex runs with its sandbox off, and the benchmark rubrics might be online. Lock it down first, the post says, or your self-improving agent just gets very good at finding the answer key.
https://x.com/vip_besic2000/status/2112580986210779187
vip_besic2000 also flagged a line in the Harness-squared README: the network is wide open, Codex runs with its sandbox off, and the benchmark rubrics might be online. Lock it down first, the post says, or your self-improving agent just gets very good at finding the answer key.
#17
@stas_sorokin_
https://x.com/stas_sorokin_/status/2113015467556106605
stas_sorokin_ argued that raw code volume is not the moat, the agent loop is, and backed it with a test: on a 67-file repo with planted bugs, Claude Code with no notes beat Codex holding a note by 2.4x. It is a small experiment, but it is a measured comparison of harness behavior rather than model claims.
https://x.com/stas_sorokin_/status/2113015467556106605
stas_sorokin_ argued that raw code volume is not the moat, the agent loop is, and backed it with a test: on a 67-file repo with planted bugs, Claude Code with no notes beat Codex holding a note by 2.4x. It is a small experiment, but it is a measured comparison of harness behavior rather than model claims.
#18
@Shaan_GS
https://x.com/Shaan_GS/status/2112884102626181442
Shaan_GS noted that OpenClaw's frontend migration from Lit to Solid 2.0 took about two weeks and roughly 600 PRs with an agent loop. The 600 is the part that matters to them: hundreds of small reviewable changes beat an agent dumping one massive migration PR on a reviewer.
https://x.com/Shaan_GS/status/2112884102626181442
Shaan_GS noted that OpenClaw's frontend migration from Lit to Solid 2.0 took about two weeks and roughly 600 PRs with an agent loop. The 600 is the part that matters to them: hundreds of small reviewable changes beat an agent dumping one massive migration PR on a reviewer.
#19
@myargoquest
https://x.com/myargoquest/status/2112935867056574524
myargoquest summarized a paper that defines loop engineering and mines 36,710 repositories to see who actually runs loops. Its definition of a well-built agent loop has six parts: a trigger, a stop condition a machine can check, a verifier that is not the worker, state on disk, a token budget, and a point where it escalates to a human.
https://x.com/myargoquest/status/2112935867056574524
myargoquest summarized a paper that defines loop engineering and mines 36,710 repositories to see who actually runs loops. Its definition of a well-built agent loop has six parts: a trigger, a stop condition a machine can check, a verifier that is not the worker, state on disk, a token budget, and a point where it escalates to a human.
#20
@blelbach
https://x.com/blelbach/status/2112447740214956426
blelbach said the hardest problem for them is that auto-research systems preserve learnings and patterns from prior experiments, and asked how anyone prevents bad learnings from getting into the knowledge base. It is the memory version of the proposer-should-not-judge rule, and nobody in the replies has a clean answer yet.
https://x.com/blelbach/status/2112447740214956426
blelbach said the hardest problem for them is that auto-research systems preserve learnings and patterns from prior experiments, and asked how anyone prevents bad learnings from getting into the knowledge base. It is the memory version of the proposer-should-not-judge rule, and nobody in the replies has a clean answer yet.
#21
@_ScottCondron
https://x.com/_ScottCondron/status/2112464345728721085
_ScottCondron sketched auto-research on idle GPU capacity: a queue of ideas for agents to try whenever GPUs are not doing higher-priority work. On CoreWeave that means Slurm on Kubernetes with preemption so priority jobs win, GPU sandboxes for agent-written code, spot capacity, and dedicated inference with hints that rank the agents' own model calls below production traffic, with traces, evals and training runs in one view.
https://x.com/_ScottCondron/status/2112464345728721085
_ScottCondron sketched auto-research on idle GPU capacity: a queue of ideas for agents to try whenever GPUs are not doing higher-priority work. On CoreWeave that means Slurm on Kubernetes with preemption so priority jobs win, GPU sandboxes for agent-written code, spot capacity, and dedicated inference with hints that rank the agents' own model calls below production traffic, with traces, evals and training runs in one view.
#22
@langfuse
https://x.com/langfuse/status/2112956107870122070
langfuse wrote up how they built their in-product agent Halo. It uses the same MCP server, skill and docs that external agents use to access Langfuse, so every new Halo capability is immediately available to everyone else's agents. The agent loop runs separately from its sandbox, and Langfuse itself is used to observe and improve Halo.
https://x.com/langfuse/status/2112956107870122070
langfuse wrote up how they built their in-product agent Halo. It uses the same MCP server, skill and docs that external agents use to access Langfuse, so every new Halo capability is immediately available to everyone else's agents. The agent loop runs separately from its sandbox, and Langfuse itself is used to observe and improve Halo.
#23
@chaliy
https://x.com/chaliy/status/2112996017964752901
chaliy described the same design choice from experience: the agent loop stays external to where tools run, because with the loop inside the sandbox one crash kills both. They also experimented with a single agent loop driving N sandboxes, which worked but has no practical solution yet.
https://x.com/chaliy/status/2112996017964752901
chaliy described the same design choice from experience: the agent loop stays external to where tools run, because with the loop inside the sandbox one crash kills both. They also experimented with a single agent loop driving N sandboxes, which worked but has no practical solution yet.
#24
@hwchase17
https://x.com/hwchase17/status/2112602732984938689
hwchase17 drew the line between the harness and the product around it: deep agents is the harness, the agent loop, and managed deep agents adds what you need once lots of people call the same agent, meaning each user's own credentials and their own memory. It is a small post, but per-user credentials and memory are exactly what loops lack when they leave one person's laptop.
https://x.com/hwchase17/status/2112602732984938689
hwchase17 drew the line between the harness and the product around it: deep agents is the harness, the agent loop, and managed deep agents adds what you need once lots of people call the same agent, meaning each user's own credentials and their own memory. It is a small post, but per-user credentials and memory are exactly what loops lack when they leave one person's laptop.
#25
@Madeactual
https://x.com/Madeactual/status/2112955832141033627
Madeactual named one thing that breaks early in agent loops: retries. A loop that retries a tool call can send the same email or charge the same card twice. The fix is to give every side-effecting tool an idempotency key and log each tool call with its inputs, so you can replay what actually happened.
https://x.com/Madeactual/status/2112955832141033627
Madeactual named one thing that breaks early in agent loops: retries. A loop that retries a tool call can send the same email or charge the same card twice. The fix is to give every side-effecting tool an idempotency key and log each tool call with its inputs, so you can replay what actually happened.
#26
@AgerardF52453
https://x.com/AgerardF52453/status/2112406174343860619
AgerardF52453 pushed back on dropping LangGraph for a free-form agent loop: it swaps setup pain for debugging blind, because a rigid script tells you which step died while the loop gives you an unexplained failure. Their example is a browser task where the verification step reported failure after the action had already succeeded, because the check broke, not the action.
https://x.com/AgerardF52453/status/2112406174343860619
AgerardF52453 pushed back on dropping LangGraph for a free-form agent loop: it swaps setup pain for debugging blind, because a rigid script tells you which step died while the loop gives you an unexplained failure. Their example is a browser task where the verification step reported failure after the action had already succeeded, because the check broke, not the action.
#27
@raphael_dkhn
https://x.com/raphael_dkhn/status/2112987464633880976
raphael_dkhn has been letting agents run autoresearch on an architecture for several days: define a metric, freeze the eval, keep what improves the score and revert what does not, then let the harness recursively improve its own research process. Inspired by Karpathy's autoresearch, Yukon Research and Harness-squared, they packaged the workflow as a small Claude Code plugin and opened it for contributions.
https://x.com/raphael_dkhn/status/2112987464633880976
raphael_dkhn has been letting agents run autoresearch on an architecture for several days: define a metric, freeze the eval, keep what improves the score and revert what does not, then let the harness recursively improve its own research process. Inspired by Karpathy's autoresearch, Yukon Research and Harness-squared, they packaged the workflow as a small Claude Code plugin and opened it for contributions.
#28
@tejasktwt
https://x.com/tejasktwt/status/2112934675501240535
tejasktwt says the best part of auto research is the human-AI collaboration: the big jumps in their results still came from suggestions based on their own intuition. But they could only reach those approaches because Opus produced so many experiments to analyze first.
https://x.com/tejasktwt/status/2112934675501240535
tejasktwt says the best part of auto research is the human-AI collaboration: the big jumps in their results still came from suggestions based on their own intuition. But they could only reach those approaches because Opus produced so many experiments to analyze first.
#29
@verbal72
https://x.com/verbal72/status/2112994915462341000
verbal72 underlined the phrase at short contexts in Recursive's own speed claim. An agent loop appends every tool result, so 125 tokens a second at 2K context is not what you get at 80K, and 2.5B active parameters cuts compute but not memory, since all 40B still has to sit in RAM.
https://x.com/verbal72/status/2112994915462341000
verbal72 underlined the phrase at short contexts in Recursive's own speed claim. An agent loop appends every tool result, so 125 tokens a second at 2K context is not what you get at 80K, and 2.5B active parameters cuts compute but not memory, since all 40B still has to sit in RAM.
#30
@grok
https://x.com/grok/status/2112933699196977632
grok posted a summary of an Anthropic Applied AI talk on self-improving agent loops via memory. The arc runs from CLAUDE.md to in-band memory tools to skills with progressive disclosure to a filesystem of markdown agents manage with bash and grep, with production needs listed as versioning, hash concurrency, permissioning and portability. Dreaming is an async out-of-band process that reviews transcripts, spots fleet-wide patterns and proposes memory updates, with roughly 97 percent fewer first-pass errors reported.
https://x.com/grok/status/2112933699196977632
grok posted a summary of an Anthropic Applied AI talk on self-improving agent loops via memory. The arc runs from CLAUDE.md to in-band memory tools to skills with progressive disclosure to a filesystem of markdown agents manage with bash and grep, with production needs listed as versioning, hash concurrency, permissioning and portability. Dreaming is an async out-of-band process that reviews transcripts, spots fleet-wide patterns and proposes memory updates, with roughly 97 percent fewer first-pass errors reported.
#31
@iamMrDuncan
https://x.com/iamMrDuncan/status/2112746490296754611
iamMrDuncan built a local rig for autoresearch: llama.cpp compiled from source for Volta, layers split across three cards over PCIe with no NVLink, an 8-bit KV cache, tool calls and thinking both working, at about 87 of 96 GB VRAM and 36 to 50 degrees C under load. Next is a head-to-head of two local models for autoresearch. In another reply they say they value quality over speed and will let pipelines run hours longer for a better result.
https://x.com/iamMrDuncan/status/2112746490296754611
iamMrDuncan built a local rig for autoresearch: llama.cpp compiled from source for Volta, layers split across three cards over PCIe with no NVLink, an 8-bit KV cache, tool calls and thinking both working, at about 87 of 96 GB VRAM and 36 to 50 degrees C under load. Next is a head-to-head of two local models for autoresearch. In another reply they say they value quality over speed and will let pipelines run hours longer for a better result.
#32
@DimitrisPapail
https://x.com/DimitrisPapail/status/2112560241506205935
DimitrisPapail conjectured that within a year we will see operating systems native to agents, called noOS, with a single mega app on top and a pot of flops underneath. The observation behind it is personal: the only apps they really use now are Claude or Codex plus messaging, and slides made in Claude are just HTML with a thin keynote-like layer. If the main user of the OS is an agent that launches programs, runs autoresearch and makes slides, most human-facing abstraction layers become useless.
https://x.com/DimitrisPapail/status/2112560241506205935
DimitrisPapail conjectured that within a year we will see operating systems native to agents, called noOS, with a single mega app on top and a pot of flops underneath. The observation behind it is personal: the only apps they really use now are Claude or Codex plus messaging, and slides made in Claude are just HTML with a thin keynote-like layer. If the main user of the OS is an agent that launches programs, runs autoresearch and makes slides, most human-facing abstraction layers become useless.
#33
@shaoxiao_si
https://x.com/shaoxiao_si/status/2112975045270364233
shaoxiao_si made the point about fast inference: at 1,521 tokens a second, generation stops being the slow part of an agent loop. The wait moves to tool calls, sandbox startup and network hops, so a team adopting it will find most of its latency budget outside the model, and a per-step trace would show the split.
https://x.com/shaoxiao_si/status/2112975045270364233
shaoxiao_si made the point about fast inference: at 1,521 tokens a second, generation stops being the slow part of an agent loop. The wait moves to tool calls, sandbox startup and network hops, so a team adopting it will find most of its latency budget outside the model, and a per-step trace would show the split.
#34
@samir_sawarkar
https://x.com/samir_sawarkar/status/2112532536299802824
samir_sawarkar argued that running a 400-billion-parameter model for every step of an agentic loop is architectural malpractice: twenty turns at three thousand prompt tokens each just to validate parameters adds up to two dollars and forty seconds a task. The proposed design routes about 90 percent of the loop to a small model that validates schemas, formats commands and checks state transitions, and wakes the frontier model only when deterministic validation fails or real planning is needed.
https://x.com/samir_sawarkar/status/2112532536299802824
samir_sawarkar argued that running a 400-billion-parameter model for every step of an agentic loop is architectural malpractice: twenty turns at three thousand prompt tokens each just to validate parameters adds up to two dollars and forty seconds a task. The proposed design routes about 90 percent of the loop to a small model that validates schemas, formats commands and checks state transitions, and wakes the frontier model only when deterministic validation fails or real planning is needed.
#35
@RohanArun
https://x.com/RohanArun/status/2112972967680541144
RohanArun's QRH repo got its first sponsor, Agent37, offering free sandboxes to the first 100 contributors who point an agent at the repo's auto-research guide and submit a PR. Sandboxes help fan out experiments in parallel and run the Lean search verifiers, and the plan is one-click CPU Lean verifiers in the harness so anyone can press play on open problems for free.
https://x.com/RohanArun/status/2112972967680541144
RohanArun's QRH repo got its first sponsor, Agent37, offering free sandboxes to the first 100 contributors who point an agent at the repo's auto-research guide and submit a PR. Sandboxes help fan out experiments in parallel and run the Lean search verifiers, and the plan is one-click CPU Lean verifiers in the harness so anyone can press play on open problems for free.
#36
@xybrid_ai
https://x.com/xybrid_ai/status/2112560723624927693
xybrid_ai demoed a fully local agentic loop at a live event: about 15 voice commands and tool calls in one run, covering survey, atmosphere scans, a drone camera, navigation and lift-off. Strangers asked for things that were never scripted, like explore the area, and it still understood.
https://x.com/xybrid_ai/status/2112560723624927693
xybrid_ai demoed a fully local agentic loop at a live event: about 15 voice commands and tool calls in one run, covering survey, atmosphere scans, a drone camera, navigation and lift-off. Strangers asked for things that were never scripted, like explore the area, and it still understood.
π‘ Eco Products Radar
Eco Products Radar
Flint (Recursive): the open-weight 40B coding model built with an autoresearch system, discussed in launch posts, OpenRouter, Ollama speed questions and context caveats.
Harness-squared: Google's self-editing harness paper and repo, read for its blueprint, its failure analysis and its README warnings.
Claude Code: the most common harness in this feed, both as the loop being studied and the base for autoresearch plugins.
Codex: the other default executor, in harness repos, cross-model benchmarks and research-agent scoreboards.
Lean: the verifier that makes the QRH hillclimb safe to automate, now usable from a plain CPU search.
OpenResearch (alphaXiv): open-source app turning coding agents into research agents, with a public scoreboard of model usage.
LangGraph and deep agents: the structured-workflow versus harness debate, with managed deep agents adding per-user credentials and memory.
Sandboxes: Agent37, Daytona and CoreWeave sandboxes all pitched as the compute autoresearch will consume.
Flint (Recursive): the open-weight 40B coding model built with an autoresearch system, discussed in launch posts, OpenRouter, Ollama speed questions and context caveats.
Harness-squared: Google's self-editing harness paper and repo, read for its blueprint, its failure analysis and its README warnings.
Claude Code: the most common harness in this feed, both as the loop being studied and the base for autoresearch plugins.
Codex: the other default executor, in harness repos, cross-model benchmarks and research-agent scoreboards.
Lean: the verifier that makes the QRH hillclimb safe to automate, now usable from a plain CPU search.
OpenResearch (alphaXiv): open-source app turning coding agents into research agents, with a public scoreboard of model usage.
LangGraph and deep agents: the structured-workflow versus harness debate, with managed deep agents adding per-user credentials and memory.
Sandboxes: Agent37, Daytona and CoreWeave sandboxes all pitched as the compute autoresearch will consume.
Comments