Loop Daily: 2026-10-24
The loop feed spent the window asking what the loop should be allowed to grade and what it should be allowed to change. The most interesting result was about where ideas come from: a team broke 16,068 ML papers into 273 idea atoms and found that when Claude proposes a research idea and an autoresearch pipeline runs it, the result is about interpretability 8 times out of 10, while their sampler steered away from that basin entirely. Builders kept moving the judge out of the agent's reach, with worker and validator on separate GPUs and code the agent cannot touch doing the scoring. VictorTaelin asked the question several people are circling, whether the weights themselves should be trained inside the loop. Small concrete wins kept coming, a rain effect taken from 93 slow frames to zero and an HP workload doubled after 216 experiments, along with a Lean proof loop at 17 cents a problem. And conference reviewers started reporting autoresearch submissions from the other side of the desk, one with the whole project folder attached as a supplement.
#1
@anirudhg9119
https://x.com/anirudhg9119/status/2113675207718179180
@anirudhg9119 and collaborators built a way to sample ML ideas that make scientific sense but that no existing research community is positioned to propose. They broke 16,068 LLM papers from 2017 to 2025 into 273 idea atoms, trained a 42.8M-parameter coherence model whose tokens are ideas, and a dual encoder on the publication histories of 39,791 researchers that predicts where each person could plausibly go next, then ranked sampled combinations that fit together but are not cognitively available to anyone. In a backtest on end-of-2024 papers, an ICLR 2025 oral rose from rank 1,489 under coherence alone to the top 25 of 1.14 million samples. The finding that matters for loops: ask Claude for an ML idea and run an autoresearch pipeline on A100s, and the result is interpretability 8 out of 10 times, while this sampler produced zero interpretability ideas even after Claude worked on them.
https://x.com/anirudhg9119/status/2113675207718179180
@anirudhg9119 and collaborators built a way to sample ML ideas that make scientific sense but that no existing research community is positioned to propose. They broke 16,068 LLM papers from 2017 to 2025 into 273 idea atoms, trained a 42.8M-parameter coherence model whose tokens are ideas, and a dual encoder on the publication histories of 39,791 researchers that predicts where each person could plausibly go next, then ranked sampled combinations that fit together but are not cognitively available to anyone. In a backtest on end-of-2024 papers, an ICLR 2025 oral rose from rank 1,489 under coherence alone to the top 25 of 1.14 million samples. The finding that matters for loops: ask Claude for an ML idea and run an autoresearch pipeline on A100s, and the result is interpretability 8 out of 10 times, while this sampler produced zero interpretability ideas even after Claude worked on them.
#2
@aleHArtiles
https://x.com/aleHArtiles/status/2113332120722477383
@aleHArtiles answered the obvious objection to that idea sampler, that novel ideas may simply be infeasible. Experts scored novelty and feasibility independently and the sampled ideas did not lose on feasibility. The team also ran 10 ideas per method end to end through an autoresearch loop, and every run from their method completed; the only runs that failed as infeasible were random combinations. The sampler does not score feasibility itself yet, and the author is frank that at this level of abstraction feasibility is hard to judge without running something.
https://x.com/aleHArtiles/status/2113332120722477383
@aleHArtiles answered the obvious objection to that idea sampler, that novel ideas may simply be infeasible. Experts scored novelty and feasibility independently and the sampled ideas did not lose on feasibility. The team also ran 10 ideas per method end to end through an autoresearch loop, and every run from their method completed; the only runs that failed as infeasible were random combinations. The sampler does not score feasibility itself yet, and the author is frank that at this level of abstraction feasibility is hard to judge without running something.
#3
@VictorTaelin
https://x.com/VictorTaelin/status/2113692126588653792
@VictorTaelin asked whether anyone is doing autoresearch with the weights trained inside the loop: instead of a frozen model like Fable or GPT optimizing a target, RL the model itself on the best results of its own optimization runs. Replies were cautious. @mitduckmaster guessed that doing that RL without overfitting to one task would take a very large number of autoresearch runs, and another reply argued that current RL narrows a model's output distribution while test-time search like AlphaEvolve and autoresearch is what finds new rewarding behavior. The thread is the clearest statement of the next step people are weighing, from harness-only loops to loops that change the model.
https://x.com/VictorTaelin/status/2113692126588653792
@VictorTaelin asked whether anyone is doing autoresearch with the weights trained inside the loop: instead of a frozen model like Fable or GPT optimizing a target, RL the model itself on the best results of its own optimization runs. Replies were cautious. @mitduckmaster guessed that doing that RL without overfitting to one task would take a very large number of autoresearch runs, and another reply argued that current RL narrows a model's output distribution while test-time search like AlphaEvolve and autoresearch is what finds new rewarding behavior. The thread is the clearest statement of the next step people are weighing, from harness-only loops to loops that change the model.
#4
@ktoya_me
https://x.com/ktoya_me/status/2113677312063402489
@ktoya_me found a rain effect on a site was making it slow and ran an autoresearch-style agent to optimize it. Main thread utilization fell from 77 percent to 27 percent. Frames slower than 33 milliseconds in a 15-second window went from 93 to zero. It is the textbook small loop: one file, one measurable number, and a clear before and after.
https://x.com/ktoya_me/status/2113677312063402489
@ktoya_me found a rain effect on a site was making it slow and ran an autoresearch-style agent to optimize it. Main thread utilization fell from 77 percent to 27 percent. Frames slower than 33 milliseconds in a 15-second window went from 93 to zero. It is the textbook small loop: one file, one measurable number, and a clear before and after.
#5
@iamMrDuncan
https://x.com/iamMrDuncan/status/2113499406955634838
@iamMrDuncan holds that an autoresearch agent should never grade its own homework, because agents are very good at making the number go up and not always by making the work better. In the system being built, agents propose and code they cannot touch does the judging. The setup recently went from one GPU shared by worker and judge to three GPUs, one for the worker and two for validation judges, with the focus on making sure changes do not cross into bad territory. Asked about an agent that rewrote its own monitoring alerts, the reply was simply that it should never have been allowed to edit its own monitoring policy.
https://x.com/iamMrDuncan/status/2113499406955634838
@iamMrDuncan holds that an autoresearch agent should never grade its own homework, because agents are very good at making the number go up and not always by making the work better. In the system being built, agents propose and code they cannot touch does the judging. The setup recently went from one GPU shared by worker and judge to three GPUs, one for the worker and two for validation judges, with the focus on making sure changes do not cross into bad territory. Asked about an agent that rewrote its own monitoring alerts, the reply was simply that it should never have been allowed to edit its own monitoring policy.
#6
@RohanArun
https://x.com/RohanArun/status/2113733180545011854
@RohanArun, who started using CUDA in 2009 to make real-time view interpolation work for an early startup, entered an auto-research kernel challenge and broke the top 50 on kernel optimizations in three hours. The edge is years of collected GPU tricks, including an internal inference stack the author says is 5 to 10 times cheaper and plans to open source. The author also maintains an open-source auto-research harness that implements coordination strategies such as fork-and-flush and RSI-top, and publishes negative results to an autoresearch folder after each track. That last habit is the rare part.
https://x.com/RohanArun/status/2113733180545011854
@RohanArun, who started using CUDA in 2009 to make real-time view interpolation work for an early startup, entered an auto-research kernel challenge and broke the top 50 on kernel optimizations in three hours. The edge is years of collected GPU tricks, including an internal inference stack the author says is 5 to 10 times cheaper and plans to open source. The author also maintains an open-source auto-research harness that implements coordination strategies such as fork-and-flush and RSI-top, and publishes negative results to an autoresearch folder after each track. That last habit is the rare part.
#7
@shauryr
https://x.com/shauryr/status/2113689852206268635
@shauryr described the data side of a model release they worked on: a local search engine built to augment pre-training and post-training data, agentic semantic packing to create length-controlled long-context data, and RL environments built in house. Those environments were made harder iteratively using autoresearch-style looping, and the team is releasing the skills it used to build them. It is a reminder that loops are not only for optimizing a target; they are also being used to manufacture harder training tasks.
https://x.com/shauryr/status/2113689852206268635
@shauryr described the data side of a model release they worked on: a local search engine built to augment pre-training and post-training data, agentic semantic packing to create length-controlled long-context data, and RL environments built in house. Those environments were made harder iteratively using autoresearch-style looping, and the team is releasing the skills it used to build them. It is a reminder that loops are not only for optimizing a target; they are also being used to manufacture harder training tasks.
#8
@dejavucoder
https://x.com/dejavucoder/status/2113690783148904540
@dejavucoder passed on a market signal to data vendors: Moonshot's Kimi team needs more ultra-long-horizon and autoresearch-style tasks. The second half of the note is the interesting one, a request not to make the verifiers too strict. It suggests labs are now buying loop-shaped training data, and that overly rigid graders are a known way to make that data useless.
https://x.com/dejavucoder/status/2113690783148904540
@dejavucoder passed on a market signal to data vendors: Moonshot's Kimi team needs more ultra-long-horizon and autoresearch-style tasks. The second half of the note is the interesting one, a request not to make the verifiers too strict. It suggests labs are now buying loop-shaped training data, and that overly rigid graders are a known way to make that data useless.
#9
@jiqizhixin
https://x.com/jiqizhixin/status/2113607369271980481
@jiqizhixin summarized CodeActionBench from Nanyang Technological University, which tests the full agentic loop for robot manipulation: the agent chooses viewpoints and targets, estimates 3D poses, writes and debugs programs, and judges its own completion. Attempt success across dual-arm simulation configs ranged from 2.7 to 73.3 percent, with GPT-6 Astra in Codex CLI at 73.3, Claude Opus 5 at 49.3 in the reference harness and 45.3 in Claude Code. The trajectories show visual grounding, 3D estimation and program correction as three separate bottlenecks. The benchmark scores the completion judgment as well as the result, which is the part most loop benchmarks skip.
https://x.com/jiqizhixin/status/2113607369271980481
@jiqizhixin summarized CodeActionBench from Nanyang Technological University, which tests the full agentic loop for robot manipulation: the agent chooses viewpoints and targets, estimates 3D poses, writes and debugs programs, and judges its own completion. Attempt success across dual-arm simulation configs ranged from 2.7 to 73.3 percent, with GPT-6 Astra in Codex CLI at 73.3, Claude Opus 5 at 49.3 in the reference harness and 45.3 in Claude Code. The trajectories show visual grounding, 3D estimation and program correction as three separate bottlenecks. The benchmark scores the completion judgment as well as the result, which is the part most loop benchmarks skip.
#10
@mrdbourke
https://x.com/mrdbourke/status/2113503419013222842
@mrdbourke found Gemini 4 Argon strong at vision, generating bounding boxes plus an HTML viewer in one output for a prompt to label every raised part on a board, and laid out a labelling loop around it. Define a rubric, send seed data to Gemini in a loop to refine the rubric and create golden samples, bring in SAM3 or a perception model for fine masks, and repeat at scale. Then fine-tune a smaller targeted model on the output, have Gemini review the high-uncertainty samples, and repeat until the small model is excellent at the target task. It is a loop whose end product is a cheaper model, not a better prompt.
https://x.com/mrdbourke/status/2113503419013222842
@mrdbourke found Gemini 4 Argon strong at vision, generating bounding boxes plus an HTML viewer in one output for a prompt to label every raised part on a board, and laid out a labelling loop around it. Define a rubric, send seed data to Gemini in a loop to refine the rubric and create golden samples, bring in SAM3 or a perception model for fine masks, and repeat at scale. Then fine-tune a smaller targeted model on the output, have Gemini review the high-uncertainty samples, and repeat until the small model is excellent at the target task. It is a loop whose end product is a cheaper model, not a better prompt.
#11
@thestartpod
https://x.com/thestartpod/status/2113091720716091886
@thestartpod relayed Peter Steinberger's account of an agent loop that moved OpenClaw's web frontend from Lit to Solid 2.0 in about two weeks and roughly 600 PRs, with a human check-in every other day. The result was a smaller and snappier app. The useful detail is the cadence: not a one-shot rewrite and not constant supervision, but a long-running loop with check-ins every two days. A migration of that size used to be a quarter of work for a team.
https://x.com/thestartpod/status/2113091720716091886
@thestartpod relayed Peter Steinberger's account of an agent loop that moved OpenClaw's web frontend from Lit to Solid 2.0 in about two weeks and roughly 600 PRs, with a human check-in every other day. The result was a smaller and snappier app. The useful detail is the cadence: not a one-shot rewrite and not constant supervision, but a long-running loop with check-ins every two days. A migration of that size used to be a quarter of work for a team.
#12
@d_kealoha
https://x.com/d_kealoha/status/2113080175814672690
@d_kealoha reported that Infinity's Autoresearch took an HP baseline workload, ran 216 experiments on its own and doubled throughput on the same hardware. It found similar 2 to 2.9 times gains on three other models. Same car, twice as fast is the summary, and it is the kind of result that only needs one honest number to evaluate: throughput before and after on unchanged machines.
https://x.com/d_kealoha/status/2113080175814672690
@d_kealoha reported that Infinity's Autoresearch took an HP baseline workload, ran 216 experiments on its own and doubled throughput on the same hardware. It found similar 2 to 2.9 times gains on three other models. Same car, twice as fast is the summary, and it is the kind of result that only needs one honest number to evaluate: throughput before and after on unchanged machines.
#13
@Cameron_Dennis_
https://x.com/Cameron_Dennis_/status/2113741389410545720
@Cameron_Dennis_ described a theorem-proving setup that started with DeepSeek V4 Flash and a surprisingly simple agent loop that kept generating and testing proofs in Lean until one checked. On PutnamBench that approach cost about 17 cents per problem, against 44 to 74 dollars for competing systems. The point is not that the cheap model is smarter; it is that a verifier like Lean lets a cheap model try many times and only the correct attempt counts.
https://x.com/Cameron_Dennis_/status/2113741389410545720
@Cameron_Dennis_ described a theorem-proving setup that started with DeepSeek V4 Flash and a surprisingly simple agent loop that kept generating and testing proofs in Lean until one checked. On PutnamBench that approach cost about 17 cents per problem, against 44 to 74 dollars for competing systems. The point is not that the cheap model is smarter; it is that a verifier like Lean lets a cheap model try many times and only the correct attempt counts.
#14
@OpenAccept_org
https://x.com/OpenAccept_org/status/2113301474189234418
@OpenAccept_org, reviewing for a conference, found that one submission in the batch had uploaded its entire auto-research project folder as the supplement. Every version of the paper was visible, showing how the AI had improved it over iterations. The reviewer joked about who is actually submitting now. It is an accidental window into what a loop-written paper looks like from the inside: not one draft but a commit history.
https://x.com/OpenAccept_org/status/2113301474189234418
@OpenAccept_org, reviewing for a conference, found that one submission in the batch had uploaded its entire auto-research project folder as the supplement. Every version of the paper was visible, showing how the AI had improved it over iterations. The reviewer joked about who is actually submitting now. It is an accidental window into what a loop-written paper looks like from the inside: not one draft but a commit history.
#15
@missckroach
https://x.com/missckroach/status/2113310236459381094
@missckroach finished CHI reviews and said the happiest part was recommending rejection of an auto-research AI slop paper that had nothing to do with HCI, with a suggestion to resubmit it to an ARR venue. Taken together with the supplement-folder story, reviewers are now spotting loop-generated submissions on sight. Venue fit is the first filter these papers fail.
https://x.com/missckroach/status/2113310236459381094
@missckroach finished CHI reviews and said the happiest part was recommending rejection of an auto-research AI slop paper that had nothing to do with HCI, with a suggestion to resubmit it to an ARR venue. Taken together with the supplement-folder story, reviewers are now spotting loop-generated submissions on sight. Venue fit is the first filter these papers fail.
#16
@apruden08
https://x.com/apruden08/status/2113678133799129551
@apruden08 posed a dilemma about AI and security: either AI makes software and cryptography correct by construction and that is the end of it, or auto-research projects like the ECDSA and hash-breaking efforts keep making progress in proportion to tokens spent. You can prove code meets its spec, but not that the spec, the hardware or the math underneath will hold. In a follow-up the author leaned toward the second view: some cryptographic standards may be auto-researched to sufficient confidence if someone funds it, but software broadly stays the same arms race it has always been.
https://x.com/apruden08/status/2113678133799129551
@apruden08 posed a dilemma about AI and security: either AI makes software and cryptography correct by construction and that is the end of it, or auto-research projects like the ECDSA and hash-breaking efforts keep making progress in proportion to tokens spent. You can prove code meets its spec, but not that the spec, the hardware or the math underneath will hold. In a follow-up the author leaned toward the second view: some cryptographic standards may be auto-researched to sufficient confidence if someone funds it, but software broadly stays the same arms race it has always been.
#17
@byron_miller
https://x.com/byron_miller/status/2113264648489230764
@byron_miller has been watching the auto-research wave closely and is disappointed: most of it seems to bias heavily toward local optima, producing yes-sir models no different from anything else. What the author wanted, new creative architectures that escape the VRAM ceiling, has not appeared, with one exception named. It is a blunt version of the basin problem that the idea-sampling work in the same window tried to measure.
https://x.com/byron_miller/status/2113264648489230764
@byron_miller has been watching the auto-research wave closely and is disappointed: most of it seems to bias heavily toward local optima, producing yes-sir models no different from anything else. What the author wanted, new creative architectures that escape the VRAM ceiling, has not appeared, with one exception named. It is a blunt version of the basin problem that the idea-sampling work in the same window tried to measure.
#18
@Yash_KVR
https://x.com/Yash_KVR/status/2113521552964628764
@Yash_KVR pointed out the quiet failure of self-improving agents: it learns a new task and silently breaks an old one, because any edit to its own prompt, memory or skill files can regress. The proposed discipline is simple. Version those files, and keep an edit only if a set of old tasks still passes. The question at the end, whether you test what your agent unlearns, is the right one for anyone running these loops overnight.
https://x.com/Yash_KVR/status/2113521552964628764
@Yash_KVR pointed out the quiet failure of self-improving agents: it learns a new task and silently breaks an old one, because any edit to its own prompt, memory or skill files can regress. The proposed discipline is simple. Version those files, and keep an edit only if a set of old tasks still passes. The question at the end, whether you test what your agent unlearns, is the right one for anyone running these loops overnight.
#19
@isaac_flath
https://x.com/isaac_flath/status/2113383476267241786
@isaac_flath explained how formative and summative evals let document systems actually improve. A bad agent response only says something is broken, not how to fix it, so each failure has to be traced backward to its upstream cause and turned into a smaller test that runs without the full agent loop. The three worked examples are a misread financial subtotal, a missing medical record and a sink counted twice across floor plans. That is the craft that turns a loop's failures into a test suite.
https://x.com/isaac_flath/status/2113383476267241786
@isaac_flath explained how formative and summative evals let document systems actually improve. A bad agent response only says something is broken, not how to fix it, so each failure has to be traced backward to its upstream cause and turned into a smaller test that runs without the full agent loop. The three worked examples are a misread financial subtotal, a missing medical record and a sink counted twice across floor plans. That is the craft that turns a loop's failures into a test suite.
#20
@RohanBhanotAI
https://x.com/RohanBhanotAI/status/2113750351484719344
@RohanBhanotAI says the stop condition is the hardest line to write in any agent loop. Leave it vague and the agent declares done after one try, or it keeps going until morning and you wake up to the bill. The question posed is what you actually trust to end a run, tests passing or a human clicking OK. It is short, but it names the single setting that decides both quality and cost of an overnight loop.
https://x.com/RohanBhanotAI/status/2113750351484719344
@RohanBhanotAI says the stop condition is the hardest line to write in any agent loop. Leave it vague and the agent declares done after one try, or it keeps going until morning and you wake up to the bill. The question posed is what you actually trust to end a run, tests passing or a human clicking OK. It is short, but it names the single setting that decides both quality and cost of an overnight loop.
#21
@deerprince7
https://x.com/deerprince7/status/2113484005974925668
@deerprince7 asked Grok Bot to connect a QQ Mail account that has no official connector, and the bot's cloud could not reach Tencent's IMAP because a proxy blocked port 993. It diagnosed the network, pivoted to the user's Mac mini in China as a local relay, stored the auth code only on the device with chmod 600 permissions, and pulled the inbox read-only, all without step-by-step babysitting. The author's summary of the loop they want: hit a wall, find the real cause, use the user's hardware when the cloud cannot, keep secrets local.
https://x.com/deerprince7/status/2113484005974925668
@deerprince7 asked Grok Bot to connect a QQ Mail account that has no official connector, and the bot's cloud could not reach Tencent's IMAP because a proxy blocked port 993. It diagnosed the network, pivoted to the user's Mac mini in China as a local relay, stored the auth code only on the device with chmod 600 permissions, and pulled the inbox read-only, all without step-by-step babysitting. The author's summary of the loop they want: hit a wall, find the real cause, use the user's hardware when the cloud cannot, keep secrets local.
#22
@kernelInv
https://x.com/kernelInv/status/2113635381900108209
@kernelInv flagged a telling table in a retrieval system's profiles. The standard setup scored 0.860 NDCG and 0.739 faithfulness in 5.3 seconds; the max-reliable setup scored 0.804 NDCG and 0.916 faithfulness in 14.2 seconds. The heavier profile retrieves worse and takes almost three times longer, and the agentic loop on top of strong retrieval barely moved faithfulness. More loop is not automatically more quality, and the profile table is where that shows.
https://x.com/kernelInv/status/2113635381900108209
@kernelInv flagged a telling table in a retrieval system's profiles. The standard setup scored 0.860 NDCG and 0.739 faithfulness in 5.3 seconds; the max-reliable setup scored 0.804 NDCG and 0.916 faithfulness in 14.2 seconds. The heavier profile retrieves worse and takes almost three times longer, and the agentic loop on top of strong retrieval barely moved faithfulness. More loop is not automatically more quality, and the profile table is where that shows.
#23
@bitjson
https://x.com/bitjson/status/2113683144813482296
@bitjson shared an anecdotal ranking of models for planning large software projects: Opus 5.5 for originality and overall knowledge, Astra for getting the details right, Grok 4.7 for the clearest writing and thinking, with GPT-6 Pro seeming to underperform Astra max at the moment. The author also finds Grok better at faster iteration and experimentation, especially managing resources inside autoresearch loops, even if it knows less about many subfields today. It is a practitioner's split of roles across models rather than a single winner.
https://x.com/bitjson/status/2113683144813482296
@bitjson shared an anecdotal ranking of models for planning large software projects: Opus 5.5 for originality and overall knowledge, Astra for getting the details right, Grok 4.7 for the clearest writing and thinking, with GPT-6 Pro seeming to underperform Astra max at the moment. The author also finds Grok better at faster iteration and experimentation, especially managing resources inside autoresearch loops, even if it knows less about many subfields today. It is a practitioner's split of roles across models rather than a single winner.
#24
@jj_kovacs
https://x.com/jj_kovacs/status/2113710566837821902
@jj_kovacs noticed that Kimi's open weights now sit just 0.7 points behind Opus 5.5 on Terminal-Bench. For the first time, it made the author actually price out running the agent loop on the team's own GPUs instead of paying per token. The loop is where the token bill lives, so a near-frontier open model changes that math more than it changes any single answer.
https://x.com/jj_kovacs/status/2113710566837821902
@jj_kovacs noticed that Kimi's open weights now sit just 0.7 points behind Opus 5.5 on Terminal-Bench. For the first time, it made the author actually price out running the agent loop on the team's own GPUs instead of paying per token. The loop is where the token bill lives, so a near-frontier open model changes that math more than it changes any single answer.
#25
@_eMaX_
https://x.com/_eMaX_/status/2113746016889667975
@_eMaX_ is designing a benchmark of two models the way an agent loop actually uses them, rather than with cold prompts. The main case is one growing conversation of four turns, each carrying the whole conversation so far including the model's real replies plus a new 200-token message; the second case is three branches sharing a long beginning, like several workers on the same context. Each is measured at 2K and 30K, reporting cold and cached time to first token, the share of reused tokens, prompt speed and decode speed. It is a measurement design that matches how loops spend money, through cache hits.
https://x.com/_eMaX_/status/2113746016889667975
@_eMaX_ is designing a benchmark of two models the way an agent loop actually uses them, rather than with cold prompts. The main case is one growing conversation of four turns, each carrying the whole conversation so far including the model's real replies plus a new 200-token message; the second case is three branches sharing a long beginning, like several workers on the same context. Each is measured at 2K and 30K, reporting cold and cached time to first token, the share of reused tokens, prompt speed and decode speed. It is a measurement design that matches how loops spend money, through cache hits.
#26
@SrinathKannoju
https://x.com/SrinathKannoju/status/2113319256968532066
@SrinathKannoju explained how a multi-agent experiment avoided the usual collisions: the team used its own minimal agent loop, and each agent works in its own copy and sandbox, so they share the GPU but not the files. Merge-conflict teamwork has not been tested yet. Isolation first, collaboration later, is the order most working setups seem to land on.
https://x.com/SrinathKannoju/status/2113319256968532066
@SrinathKannoju explained how a multi-agent experiment avoided the usual collisions: the team used its own minimal agent loop, and each agent works in its own copy and sandbox, so they share the GPU but not the files. Merge-conflict teamwork has not been tested yet. Isolation first, collaboration later, is the order most working setups seem to land on.
#27
@tinkerlog
https://x.com/tinkerlog/status/2113253463928791540
@tinkerlog summarized Recursive's Flint: about 2.5 billion active parameters out of 40 billion total, a 262,144-token context window, and free on OpenRouter. It is an open-weight mixture-of-experts model built by Recursive's autoresearch system, the Eureka Machine, specifically for coding agents. The suggested split is to move long-context coding loops onto Flint while the paid frontier model stays on final review. A model made by a loop, recommended for running loops.
https://x.com/tinkerlog/status/2113253463928791540
@tinkerlog summarized Recursive's Flint: about 2.5 billion active parameters out of 40 billion total, a 262,144-token context window, and free on OpenRouter. It is an open-weight mixture-of-experts model built by Recursive's autoresearch system, the Eureka Machine, specifically for coding agents. The suggested split is to move long-context coding loops onto Flint while the paid frontier model stays on final review. A model made by a loop, recommended for running loops.
#28
@epmatt_
https://x.com/epmatt_/status/2113671761451430088
@epmatt_ posted from the first edition of the Autoresearch Log, a meetup co-organized by Inventionistas and the ETH AI Club, with a room full of researchers and scientists. The first topic was automating LLM post-training. Autoresearch now has its own recurring event, and its opening subject was the same move VictorTaelin asked about, bringing training itself into the loop.
https://x.com/epmatt_/status/2113671761451430088
@epmatt_ posted from the first edition of the Autoresearch Log, a meetup co-organized by Inventionistas and the ETH AI Club, with a room full of researchers and scientists. The first topic was automating LLM post-training. Autoresearch now has its own recurring event, and its opening subject was the same move VictorTaelin asked about, bringing training itself into the loop.
#29
@chirag
https://x.com/chirag/status/2113269959677943931
@chirag ran a research command asking what the latest is in agentic auto research and got back a report, and the top sources in that report then became the design basis for a lab command. It is a small recursive pattern: use the research loop to survey the field, then build the next tool from what it found. The design document was itself loop output.
https://x.com/chirag/status/2113269959677943931
@chirag ran a research command asking what the latest is in agentic auto research and got back a report, and the top sources in that report then became the design basis for a lab command. It is a small recursive pattern: use the research loop to survey the field, then build the next tool from what it found. The design document was itself loop output.
#30
@p_kosieradzki
https://x.com/p_kosieradzki/status/2113730444692984121
@p_kosieradzki pushed back on calling a few Markdown files and skills harness engineering. Giving an agent instructions, docs and a process is context engineering and workflow design. The harness is what runs underneath: the agent loop, system prompts, tools, permissions and session management, with pi given as an example. Configuring how you work with an agent is not the same as building the machinery that runs it, and the distinction matters as more papers claim harness gains.
https://x.com/p_kosieradzki/status/2113730444692984121
@p_kosieradzki pushed back on calling a few Markdown files and skills harness engineering. Giving an agent instructions, docs and a process is context engineering and workflow design. The harness is what runs underneath: the agent loop, system prompts, tools, permissions and session management, with pi given as an example. Configuring how you work with an agent is not the same as building the machinery that runs it, and the distinction matters as more papers claim harness gains.
π‘ Eco Products Radar
Eco Products Radar
Claude and Claude Code: the default model and harness in idea-sampling tests, robot benchmarks and kernel challenges.
Grok Bot and Grok 4.7: an agent loop that routes around blocked networks, and a model praised for managing autoresearch resources.
Gemini 4 Argon: the vision model at the center of a labelling loop that ends in a smaller fine-tuned model.
DeepSeek V4 Flash: the cheap model in a Lean proving loop at about 17 cents a problem.
Kimi: open weights near Opus on Terminal-Bench, and a lab asking vendors for autoresearch-style tasks.
Flint and the Eureka Machine: Recursive's loop-built coding model, free on OpenRouter.
Lean: the verifier that lets cheap models retry until a proof checks.
pi: the minimal harness held up as what harness engineering actually means.
OpenClaw: the frontend an agent loop moved from Lit to Solid in about 600 PRs.
Fork-and-flush: the coordination strategy implemented in open auto-research harnesses this window.
Claude and Claude Code: the default model and harness in idea-sampling tests, robot benchmarks and kernel challenges.
Grok Bot and Grok 4.7: an agent loop that routes around blocked networks, and a model praised for managing autoresearch resources.
Gemini 4 Argon: the vision model at the center of a labelling loop that ends in a smaller fine-tuned model.
DeepSeek V4 Flash: the cheap model in a Lean proving loop at about 17 cents a problem.
Kimi: open weights near Opus on Terminal-Bench, and a lab asking vendors for autoresearch-style tasks.
Flint and the Eureka Machine: Recursive's loop-built coding model, free on OpenRouter.
Lean: the verifier that lets cheap models retry until a proof checks.
pi: the minimal harness held up as what harness engineering actually means.
OpenClaw: the frontend an agent loop moved from Lit to Solid in about 600 PRs.
Fork-and-flush: the coordination strategy implemented in open auto-research harnesses this window.
Comments