Loop Daily: 2026-09-04
Autoresearch grew a price tag this window, and the numbers run in both directions: a week of 144 agents bought a 6.6x cheaper Ethereum verifier for $7,500, four unattended hours produced a compression algorithm that beats JPEG XL, and a robot arm learned to grab cans using its own gripper servo as a free success label. Meanwhile the verification crisis got its sharpest articulations yet: a subagent that correctly spotted the fatal bug but was not loud enough to stop the loop from amplifying it, a finished trading bot with 847 passing tests that could not send a single transaction, and a self-improvement evaluator that blamed candidates for its own flaky asyncio pipe. The benchmark layer is racing to catch up, speedruns, rubric-first science, gas-golfing tournaments, and the infrastructure layer is starting to treat the loop itself as swappable: DeepSeek made the agent loop a plugin, Cursor let the tools leave home while keeping the brain, and CMU's Reef wants to evolve weights and harness at once.
#1
@orenyomtov
https://x.com/orenyomtov/status/2095486899250962489
He ran an auto-research project with 144 Fable agents for a week, spending $7,500 on inference, and it made post-quantum signature verification on Ethereum 6.6x cheaper than the previous best hand-optimized verifier. The economics are the point: the optimization pays for itself after fewer than 900 onchain verifications. Autoresearch as a capital expenditure with a measurable payback period, not a demo.
https://x.com/orenyomtov/status/2095486899250962489
He ran an auto-research project with 144 Fable agents for a week, spending $7,500 on inference, and it made post-quantum signature verification on Ethereum 6.6x cheaper than the previous best hand-optimized verifier. The economics are the point: the optimization pays for itself after fewer than 900 onchain verifications. Autoresearch as a capital expenditure with a measurable payback period, not a demo.
#2
@keethesh_
https://x.com/keethesh_/status/2095521834363969975
He told Gemini 3.8 Flash to build a lossless compression algorithm from scratch using autoresearch and walked away for four hours. The result, FOLIO, is 1,500 lines of safe Rust that he benchmarks at 11.1x faster than JPEG XL and 7.2x faster than WebP Lossless, with raw numbers and the repo published. Whatever survives scrutiny, the loop produced a shippable artifact in an afternoon.
https://x.com/keethesh_/status/2095521834363969975
He told Gemini 3.8 Flash to build a lossless compression algorithm from scratch using autoresearch and walked away for four hours. The result, FOLIO, is 1,500 lines of safe Rust that he benchmarks at 11.1x faster than JPEG XL and 7.2x faster than WebP Lossless, with raw numbers and the repo published. Whatever survives scrutiny, the loop produced a shippable artifact in an afternoon.
#3
@omarespejel
https://x.com/omarespejel/status/2095380998431080499
His SO-101 robot arm now hands him a beer, and the interesting part is the label-free autoresearch loop: he never reviews videos or annotates anything, he just commands the gripper to close fully. If a can is inside, the servo stops at 3-9 units; if empty, it closes to zero, and that servo reading is the success label, essentially free. The same check runs in MuJoCo so simulation filters grasps before the real arm tries them; an earlier iteration cut median aiming error from 121mm to 40mm. Model and dataset are open on Hugging Face.
https://x.com/omarespejel/status/2095380998431080499
His SO-101 robot arm now hands him a beer, and the interesting part is the label-free autoresearch loop: he never reviews videos or annotates anything, he just commands the gripper to close fully. If a can is inside, the servo stops at 3-9 units; if empty, it closes to zero, and that servo reading is the success label, essentially free. The same check runs in MuJoCo so simulation filters grasps before the real arm tries them; an earlier iteration cut median aiming error from 121mm to 40mm. Model and dataset are open on Hugging Face.
#4
@askalphaxiv
https://x.com/askalphaxiv/status/2094854592995725324
Fable 5.1 is now state of the art for autoresearch by their measurement: 52.6 percent on Terminal-Bench-Science 0.1, versus 24.7 for Fable 5 and 22.4 for GPT-5.6 Sol. More than doubling the previous generation on autonomous science terminal work is the kind of jump that changes what people attempt, and it is live to try on OpenResearch.
https://x.com/askalphaxiv/status/2094854592995725324
Fable 5.1 is now state of the art for autoresearch by their measurement: 52.6 percent on Terminal-Bench-Science 0.1, versus 24.7 for Fable 5 and 22.4 for GPT-5.6 Sol. More than doubling the previous generation on autonomous science terminal work is the kind of jump that changes what people attempt, and it is live to try on OpenResearch.
#5
@DailyDoseOfDS_
https://x.com/DailyDoseOfDS_/status/2095081810032251060
The clearest map yet of the automated-optimizer landscape sitting above Karpathy's autoresearch: GEPA edits the text of a system by reading full execution traces, AutoResearch iterates a program.md against fixed evals, and Meta-Harness points the loop at the scaffolding itself. On Frontier-CS no optimizer wins everywhere, GEPA led on 3 tasks, AutoResearch on 3, Meta-Harness on 4, and each hill-climbs then stalls. The finding that matters: handing a stalled candidate to a different optimizer breaks the plateau, and the open-source omni meta-optimizer that automates this rotation scores 7.8 points above the best standalone optimizer at the same budget.
https://x.com/DailyDoseOfDS_/status/2095081810032251060
The clearest map yet of the automated-optimizer landscape sitting above Karpathy's autoresearch: GEPA edits the text of a system by reading full execution traces, AutoResearch iterates a program.md against fixed evals, and Meta-Harness points the loop at the scaffolding itself. On Frontier-CS no optimizer wins everywhere, GEPA led on 3 tasks, AutoResearch on 3, Meta-Harness on 4, and each hill-climbs then stalls. The finding that matters: handing a stalled candidate to a different optimizer breaks the plateau, and the open-source omni meta-optimizer that automates this rotation scores 7.8 points above the best standalone optimizer at the same budget.
#6
@j_foerst
https://x.com/j_foerst/status/2094738793781710951
Jakob Foerster's group tackles the autoresearch case nobody has an answer for: what if experiments take weeks and millions of dollars instead of minutes on a GPU. Human scientists cope with small-scale proofs of concept, scaling curves, and targeted experimentation, and this work is a step toward giving those capabilities to autoresearch systems. The key question they formalize: what is a good experiment to run given the cost-accuracy tradeoff curve.
https://x.com/j_foerst/status/2094738793781710951
Jakob Foerster's group tackles the autoresearch case nobody has an answer for: what if experiments take weeks and millions of dollars instead of minutes on a GPU. Human scientists cope with small-scale proofs of concept, scaling curves, and targeted experimentation, and this work is a step toward giving those capabilities to autoresearch systems. The key question they formalize: what is a good experiment to run given the cost-accuracy tradeoff curve.
#7
@eth_proofs
https://x.com/eth_proofs/status/2095543793659347427
An open autoresearch challenge went live on yukonresearch: write and benchmark EVM bytecode replacements for EIP-8200 precompiles, establishing proving-cost baselines for zkVM provers. Each promoted submission becomes the shared record to beat, and anyone with good prompts and token budget can enter their agent. Ethereum protocol R&D structured as a public agent-vs-agent gas-golfing tournament.
https://x.com/eth_proofs/status/2095543793659347427
An open autoresearch challenge went live on yukonresearch: write and benchmark EVM bytecode replacements for EIP-8200 precompiles, establishing proving-cost baselines for zkVM provers. Each promoted submission becomes the shared record to beat, and anyone with good prompts and token budget can enter their agent. Ethereum protocol R&D structured as a public agent-vs-agent gas-golfing tournament.
#8
@0xCodila
https://x.com/0xCodila/status/2095613803773788391
SpeedrunBench from Patronus AI benchmarks whether an agent can discover a strategy, run it, improve it, and keep shaving time toward near-optimal play, watched live rather than reduced to a final score. It launches with frontier closed and open models on a public leaderboard, a playable environment, and a replay library targeting 100+ hours of trajectories. Several commentators independently called the autoresearch loop the interesting part: you can watch the model waste time, recover, and change strategy.
https://x.com/0xCodila/status/2095613803773788391
SpeedrunBench from Patronus AI benchmarks whether an agent can discover a strategy, run it, improve it, and keep shaving time toward near-optimal play, watched live rather than reduced to a final score. It launches with frontier closed and open models on a public leaderboard, a playable environment, and a replay library targeting 100+ hours of trajectories. Several commentators independently called the autoresearch loop the interesting part: you can watch the model waste time, recover, and change strategy.
#9
@stretchcloud
https://x.com/stretchcloud/status/2095354597007032519
A sharp read on why Autoresearch Bench matters: standard coding benchmarks have saturated to where leaderboard position no longer predicts production outcomes, while the gap on autonomous research tasks stays stark. He inventories the exploding category, AutoResearchBench where top models score only 9.39 percent on deep-research tasks, ResearchClawBench, NatureBench with 90 tasks from Nature-family papers. The common thread: models trained to complete specified tasks are now being evaluated on tasks where no specification exists, only a goal.
https://x.com/stretchcloud/status/2095354597007032519
A sharp read on why Autoresearch Bench matters: standard coding benchmarks have saturated to where leaderboard position no longer predicts production outcomes, while the gap on autonomous research tasks stays stark. He inventories the exploding category, AutoResearchBench where top models score only 9.39 percent on deep-research tasks, ResearchClawBench, NatureBench with 90 tasks from Nature-family papers. The common thread: models trained to complete specified tasks are now being evaluated on tasks where no specification exists, only a goal.
#10
@hackhackai
https://x.com/hackhackai/status/2095482002791080047
hackhack launched an autoresearch feed of fully automated Solana security research: an agentic loop scans the ecosystem for research opportunities, explores them, validates real findings, and stages them for release, with humans reviewing and disclosing to affected projects before publication. They say the loop has already found bugs across top Solana protocols now awaiting clearance, and the first published article covers approving squads transactions for upgradeable programs. Security research as a continuously running pipeline with human sign-off at the end.
https://x.com/hackhackai/status/2095482002791080047
hackhack launched an autoresearch feed of fully automated Solana security research: an agentic loop scans the ecosystem for research opportunities, explores them, validates real findings, and stages them for release, with humans reviewing and disclosing to affected projects before publication. They say the loop has already found bugs across top Solana protocols now awaiting clearance, and the first published article covers approving squads transactions for upgradeable programs. Security research as a continuously running pipeline with human sign-off at the end.
#11
@zxlzr
https://x.com/zxlzr/status/2095447527411876286
AutoSciRub inverts the research-agent loop: instead of executing and scoring post hoc, it first induces a task-specific executable rubric, decomposing an underspecified instruction into goals grounded in literature, then lets the rubric guide which experiments to run and which evidence to collect. Gains are consistent: +2.08 points across three backbone LLMs on a fixed Codex harness, +2.95 across three harnesses on a fixed DeepSeek backbone, 33.2 Pass@1 on ResearchClawBench with GPT-5.6 Sol. Released as installable skills for Codex, Claude Code, and OpenClaw. The slogan is right: agents should learn to evaluate before improving.
https://x.com/zxlzr/status/2095447527411876286
AutoSciRub inverts the research-agent loop: instead of executing and scoring post hoc, it first induces a task-specific executable rubric, decomposing an underspecified instruction into goals grounded in literature, then lets the rubric guide which experiments to run and which evidence to collect. Gains are consistent: +2.08 points across three backbone LLMs on a fixed Codex harness, +2.95 across three harnesses on a fixed DeepSeek backbone, 33.2 Pass@1 on ResearchClawBench with GPT-5.6 Sol. Released as installable skills for Codex, Claude Code, and OpenClaw. The slogan is right: agents should learn to evaluate before improving.
#12
@ZhihuFrontier
https://x.com/ZhihuFrontier/status/2095092886069211247
A comprehensive map of recursive self-improvement organized around two questions: how far has the human moved out of the loop, and what exactly is being improved. Almost everything today sits at human-on-the-loop; improvement climbs from outputs to weights to the agent itself, and training-time RSI runs from zero-label through zero-data self-play to full auto-research. The conclusion the whole field keeps arriving at: generation is solved enough, verification is the bottleneck, and the new frontier is evolving the verifier itself without policy and evaluator drifting together.
https://x.com/ZhihuFrontier/status/2095092886069211247
A comprehensive map of recursive self-improvement organized around two questions: how far has the human moved out of the loop, and what exactly is being improved. Almost everything today sits at human-on-the-loop; improvement climbs from outputs to weights to the agent itself, and training-time RSI runs from zero-label through zero-data self-play to full auto-research. The conclusion the whole field keeps arriving at: generation is solved enough, verification is the bottleneck, and the new frontier is evolving the verifier itself without policy and evaluator drifting together.
#13
@Abaybektursun
https://x.com/Abaybektursun/status/2095596915136380933
The failure mode everyone building research loops should read: his LLM-research program turned out to be built on a buggy inference readout, and one of the subagents actually noticed the bug, but its voice was not loud enough, so the mistake got amplified into the docs and kept getting reinforced. Assisted research he rates the best there is; auto research still hit or miss. Detection without escalation is worthless in a loop, dissent needs routing, not just existence.
https://x.com/Abaybektursun/status/2095596915136380933
The failure mode everyone building research loops should read: his LLM-research program turned out to be built on a buggy inference readout, and one of the subagents actually noticed the bug, but its voice was not loud enough, so the mistake got amplified into the docs and kept getting reinforced. Assisted research he rates the best there is; auto research still hit or miss. Detection without escalation is worthless in a loop, dissent needs routing, not just existence.
#14
@whysanesanders
https://x.com/whysanesanders/status/2095595834528452702
A precise naming of what capability-hallucination benchmarks measure: the model making false claims about what it has done, which is the exact failure mode that costs days in an agent loop. His example run reported a finished trading bot, 44k lines, 847 tests, and it could not send a single transaction. If GPT-6 Astra really cut that in half, he argues, it matters more than any headline score.
https://x.com/whysanesanders/status/2095595834528452702
A precise naming of what capability-hallucination benchmarks measure: the model making false claims about what it has done, which is the exact failure mode that costs days in an agent loop. His example run reported a finished trading bot, 44k lines, 847 tests, and it could not send a single transaction. If GPT-6 Astra really cut that in half, he argues, it matters more than any headline score.
#15
@TesterArmy
https://x.com/TesterArmy/status/2095177610426974597
Their QA agent sent 310.8k tokens in to get 2.3k out, and they note a 135:1 ratio is normal for an agent loop, the raw trace just hides it. unbox-ai opens any trace as a token treemap, a latency waterfall, and a CLI for coding agents, MIT licensed, npx unbox-ai trace.json. Loop economics made visible in one command.
https://x.com/TesterArmy/status/2095177610426974597
Their QA agent sent 310.8k tokens in to get 2.3k out, and they note a 135:1 ratio is normal for an agent loop, the raw trace just hides it. unbox-ai opens any trace as a token treemap, a latency waterfall, and a CLI for coding agents, MIT licensed, npx unbox-ai trace.json. Loop economics made visible in one command.
#16
@Chris_L_Elliott
https://x.com/Chris_L_Elliott/status/2095602898293981549
From an incident postmortem thread: attackers ran a 10-hour agent loop that tried to plant Terraform backdoors, and branch protection was the one control that survived. Public API, git tokens, the vault, and the victim's own cloud AI used as command-and-control all failed. A concrete answer to which guardrails hold when the attacker is also an agentic loop.
https://x.com/Chris_L_Elliott/status/2095602898293981549
From an incident postmortem thread: attackers ran a 10-hour agent loop that tried to plant Terraform backdoors, and branch protection was the one control that survived. Public API, git tokens, the vault, and the victim's own cloud AI used as command-and-control all failed. A concrete answer to which guardrails hold when the attacker is also an agentic loop.
#17
@DevArtSolutions
https://x.com/DevArtSolutions/status/2095113568043565389
Their self-improving agent kept failing its own candidates: one test run in three failed on an asyncio detail, and since candidate validation is the test suite, candidates were being blamed for a warning about a closed pipe. A tiny war story with a big moral, flaky infrastructure in the evaluator poisons the whole selection loop, the verifier is part of the system under test.
https://x.com/DevArtSolutions/status/2095113568043565389
Their self-improving agent kept failing its own candidates: one test run in three failed on an asyncio detail, and since candidate validation is the test suite, candidates were being blamed for a warning about a closed pipe. A tiny war story with a big moral, flaky infrastructure in the evaluator poisons the whole selection loop, the verifier is part of the system under test.
#18
@shamilkch
https://x.com/shamilkch/status/2094928112324841679
One tweet worth a paper on trading-agent claims: self-improving only means something if each mutation is logged, replayable, and judged on frozen out-of-sample regimes against a non-adaptive baseline. Otherwise the agent is just overfitting its own feedback loop. The evaluation bar for the entire self-improving category, stated in two sentences.
https://x.com/shamilkch/status/2094928112324841679
One tweet worth a paper on trading-agent claims: self-improving only means something if each mutation is logged, replayable, and judged on frozen out-of-sample regimes against a non-adaptive baseline. Otherwise the agent is just overfitting its own feedback loop. The evaluation bar for the entire self-improving category, stated in two sentences.
#19
@realbarnakiss
https://x.com/realbarnakiss/status/2095571936663273785
Three failure modes he sees in every autoresearch setup regardless of quality: slowly degrading output as prosaic guards relax, falling back into base-training habits, and failing to update research on new learnings, the reinforcement part is missing from the loops. His fix is integrating mathematics deeply, letting agents set up invariants without the freedom that causes regression. His bet: next year mathematics will be the hottest programming language.
https://x.com/realbarnakiss/status/2095571936663273785
Three failure modes he sees in every autoresearch setup regardless of quality: slowly degrading output as prosaic guards relax, falling back into base-training habits, and failing to update research on new learnings, the reinforcement part is missing from the loops. His fix is integrating mathematics deeply, letting agents set up invariants without the freedom that causes regression. His bet: next year mathematics will be the hottest programming language.
#20
@rajuborda
https://x.com/rajuborda/status/2095560910639337510
Meta published CORAL, an agentic loop that does the job of a recommender-systems algorithm engineer in production: an LLM watches live signals, remembers what it tried, proposes a change, runs it through a constrained optimizer so it stays within safety budgets, ships it, then folds the measured effect back into memory. The notable part is that performance compounds across cycles as the agent gets better at reading its own history, the judgment work that used to be a human watching a dashboard.
https://x.com/rajuborda/status/2095560910639337510
Meta published CORAL, an agentic loop that does the job of a recommender-systems algorithm engineer in production: an LLM watches live signals, remembers what it tried, proposes a change, runs it through a constrained optimizer so it stays within safety budgets, ships it, then folds the measured effect back into memory. The notable part is that performance compounds across cycles as the agent gets better at reading its own history, the judgment work that used to be a human watching a dashboard.
#21
@chg80333
https://x.com/chg80333/status/2095418644293464187
Reef, from CMU's Paul Pu Liang lab, claims to be the first open-source infrastructure that evolves both model weights and the harness from deployment experience: agents are exposed as HTTP endpoints, you send requests to Reef's inference instead of the vendor's, and in the background it continuously evaluates and updates the served harness and weights. COLM 2026 accepted, from the same lab that ships CORAL for multi-agent autoresearch. He calls it the first open mirror of the RL infrastructure frontier labs run internally.
https://x.com/chg80333/status/2095418644293464187
Reef, from CMU's Paul Pu Liang lab, claims to be the first open-source infrastructure that evolves both model weights and the harness from deployment experience: agents are exposed as HTTP endpoints, you send requests to Reef's inference instead of the vendor's, and in the background it continuously evaluates and updates the served harness and weights. COLM 2026 accepted, from the same lab that ships CORAL for multi-agent autoresearch. He calls it the first open mirror of the RL infrastructure frontier labs run internally.
#22
@EyalToledano
https://x.com/EyalToledano/status/2095564645742280737
He is wiring pmlx to optimize itself over time, with a distributed autoresearch community integrated into the TUI: spawning Grok, Codex, Claude, and local autoresearch agents on a deterministic harness so they can submit experiments to improve the decode loop. Inference-engine development where outside agents are first-class contributors to your hot path.
https://x.com/EyalToledano/status/2095564645742280737
He is wiring pmlx to optimize itself over time, with a distributed autoresearch community integrated into the TUI: spawning Grok, Codex, Claude, and local autoresearch agents on a deterministic harness so they can submit experiments to improve the decode loop. Inference-engine development where outside agents are first-class contributors to your hot path.
#23
@haydonryan
https://x.com/haydonryan/status/2095322992733470742
An extreme-optimization experiment: take a Rust app, keep the function signatures and data structures, and run autoresearch-style loops that inject assembly to replace function interiors, rebuilding external dependencies in assembly locally, while ensuring tests still pass. His framing: assuming a perfect programmer, assembly should always win, so the loop measures how much bloat everything above it carries.
https://x.com/haydonryan/status/2095322992733470742
An extreme-optimization experiment: take a Rust app, keep the function signatures and data structures, and run autoresearch-style loops that inject assembly to replace function interiors, rebuilding external dependencies in assembly locally, while ensuring tests still pass. His framing: assuming a perfect programmer, assembly should always win, so the loop measures how much bloat everything above it carries.
#24
@SergioSV96
https://x.com/SergioSV96/status/2095514975104020883
Weekend infrastructure autoresearch: attaching a second GPU and pointing Karpathy's autoresearch at the setup, with Qwen 3.8 27B loaded on one GPU trying to improve inference speeds on his RX 7900 XTX while the other GPU serves as the test bench. The loop as a hardware-tuning intern.
https://x.com/SergioSV96/status/2095514975104020883
Weekend infrastructure autoresearch: attaching a second GPU and pointing Karpathy's autoresearch at the setup, with Qwen 3.8 27B loaded on one GPU trying to improve inference speeds on his RX 7900 XTX while the other GPU serves as the test bench. The loop as a hardware-tuning intern.
#25
@theotherpomp
https://x.com/theotherpomp/status/2095414786661982684
He started from a published fine-tuning recipe, fed Fable some tweets and articles he found interesting, and told it to use Karpathy's autoresearch to change one parameter at a time, running the same tests at each iteration. The minimal viable version of hyperparameter autoresearch: no framework, just discipline expressed in a prompt.
https://x.com/theotherpomp/status/2095414786661982684
He started from a published fine-tuning recipe, fed Fable some tweets and articles he found interesting, and told it to use Karpathy's autoresearch to change one parameter at a time, running the same tests at each iteration. The minimal viable version of hyperparameter autoresearch: no framework, just discipline expressed in a prompt.
#26
@ScienceGuruAI
https://x.com/ScienceGuruAI/status/2094743139181621424
Autoresearch@Home continues testing recursive self-improvement in public: one GPU, five minutes, a fixed evaluator, and a new leader, ScienceGuru + Guru Turbo 1.0 at val_bpb 0.889522. Hypotheses, code, experiments, and audited results all in the open, the distributed-volunteer format applied to AI research loops.
https://x.com/ScienceGuruAI/status/2094743139181621424
Autoresearch@Home continues testing recursive self-improvement in public: one GPU, five minutes, a fixed evaluator, and a new leader, ScienceGuru + Guru Turbo 1.0 at val_bpb 0.889522. Hypotheses, code, experiments, and audited results all in the open, the distributed-volunteer format applied to AI research loops.
#27
@Jingg_n_Tonic
https://x.com/Jingg_n_Tonic/status/2095517767415795911
Her baby woke five times in one night, so she sent Fable 5.1 in the bb app a prompt: read the open-sourced X algorithm repo, extract what makes posts go viral, then build me an autoresearch eval that scores any draft post against the algorithm and suggests a rewritten version with a new score, as a plugin. It two-shotted the whole thing. Personalized software with an autoresearch loop inside, built during night feeds.
https://x.com/Jingg_n_Tonic/status/2095517767415795911
Her baby woke five times in one night, so she sent Fable 5.1 in the bb app a prompt: read the open-sourced X algorithm repo, extract what makes posts go viral, then build me an autoresearch eval that scores any draft post against the algorithm and suggests a rewritten version with a new score, as a plugin. It two-shotted the whole thing. Personalized software with an autoresearch loop inside, built during night feeds.
#28
@varunconfirms
https://x.com/varunconfirms/status/2095535846426353883
Enterpret is building self-improving customer loops that detect, triage, and route signals to the right human or agent, then verify the fix, spanning everything from Codex bug reports to bathroom latches in retail stores. Feedback pipelines as closed loops with verification at the end, rather than dashboards someone might read.
https://x.com/varunconfirms/status/2095535846426353883
Enterpret is building self-improving customer loops that detect, triage, and route signals to the right human or agent, then verify the fix, spanning everything from Codex bug reports to bathroom latches in retail stores. Feedback pipelines as closed loops with verification at the end, rather than dashboards someone might read.
#29
@FieldToFuture
https://x.com/FieldToFuture/status/2095633468977987909
Recertia, a bootstrapped self-improving agent system for recurring work: it solves a task against locked machine-checkable criteria, saves what worked as versioned memory, and measures whether that memory actually helps next time. The stance is the interesting part, no weight updates, improvement lives entirely in how knowledge is stored, retrieved, and re-certified.
https://x.com/FieldToFuture/status/2095633468977987909
Recertia, a bootstrapped self-improving agent system for recurring work: it solves a task against locked machine-checkable criteria, saves what worked as versioned memory, and measures whether that memory actually helps next time. The stance is the interesting part, no weight updates, improvement lives entirely in how knowledge is stored, retrieved, and re-certified.
#30
@skyshark88
https://x.com/skyshark88/status/2095526071730884897
A full design for using a synced Obsidian vault as a blackboard architecture between local AI and cloud Grok Bot instances: agents communicate by reading and writing Markdown and JSON in shared folders, with file watchers as triggers. It covers the real operational hazards, single-writer rules to prevent sync conflicts, max-turn counters and approval flags to stop accidental infinite loops between bots passing files back and forth all night. Multi-agent coordination without an orchestration platform, just a file system and discipline.
https://x.com/skyshark88/status/2095526071730884897
A full design for using a synced Obsidian vault as a blackboard architecture between local AI and cloud Grok Bot instances: agents communicate by reading and writing Markdown and JSON in shared folders, with file watchers as triggers. It covers the real operational hazards, single-writer rules to prevent sync conflicts, max-turn counters and approval flags to stop accidental infinite loops between bots passing files back and forth all night. Multi-agent coordination without an orchestration platform, just a file system and discipline.
#31
@cursor_ai
https://x.com/cursor_ai/status/2095257412781396114
Cursor cloud agents can now run on your own infrastructure, including machine pools that autoscale with demand, giving agents access to internal services and specialized hardware while the agent loop stays in Cursor. Vercel simultaneously shipped support in Firecracker microVM sandboxes. The catch several practitioners flagged within hours: your code, your network, their brain, the loop itself still lives on Cursor's servers, which is exactly the boundary self-hosters care about.
https://x.com/cursor_ai/status/2095257412781396114
Cursor cloud agents can now run on your own infrastructure, including machine pools that autoscale with demand, giving agents access to internal services and specialized hardware while the agent loop stays in Cursor. Vercel simultaneously shipped support in Firecracker microVM sandboxes. The catch several practitioners flagged within hours: your code, your network, their brain, the loop itself still lives on Cursor's servers, which is exactly the boundary self-hosters care about.
#32
@Marwan_3atef
https://x.com/Marwan_3atef/status/2095620107045413373
DeepSeek shipped its open-source coding-agent harness and named the thesis out loud: everything is a plugin, models, tools, sandboxes, filesystems, even the agent loop itself. MIT licensed, Cordis under the hood, still a developer preview with breaking changes incoming. Claude Code energy, he notes, but you can swap the spine, the agent loop as a replaceable component is the interesting half of the V4-Pro push.
https://x.com/Marwan_3atef/status/2095620107045413373
DeepSeek shipped its open-source coding-agent harness and named the thesis out loud: everything is a plugin, models, tools, sandboxes, filesystems, even the agent loop itself. MIT licensed, Cordis under the hood, still a developer preview with breaking changes incoming. Claude Code energy, he notes, but you can swap the spine, the agent loop as a replaceable component is the interesting half of the V4-Pro push.
#33
@smarzani
https://x.com/smarzani/status/2095527741424857532
A live Agentic PlugFest demo claimed a safety-critical automotive V-cycle collapsed into one agentic loop, six to eight weeks of engineering in 25 minutes. Even discounted heavily, regulated-industry engineering cycles are exactly where loop compression is worth the most money, and where verification requirements make it hardest to trust.
https://x.com/smarzani/status/2095527741424857532
A live Agentic PlugFest demo claimed a safety-critical automotive V-cycle collapsed into one agentic loop, six to eight weeks of engineering in 25 minutes. Even discounted heavily, regulated-industry engineering cycles are exactly where loop compression is worth the most money, and where verification requirements make it hardest to trust.
#34
@reqeique
https://x.com/reqeique/status/2095601327325712769
After running an agent loop all week: most of what he wrote had nothing to do with the prompt, it was a state machine deciding what gets to ask the model anything. The memoized prompts were the easy part. As concise a definition of harness engineering as anyone has produced.
https://x.com/reqeique/status/2095601327325712769
After running an agent loop all week: most of what he wrote had nothing to do with the prompt, it was a state machine deciding what gets to ask the model anything. The memoized prompts were the easy part. As concise a definition of harness engineering as anyone has produced.
#35
@iamnotnicola
https://x.com/iamnotnicola/status/2095084983564063171
A research agenda for generative cryptography, what can we unlock if AI could write cryptography: AI agents engaging in cryptographic interactions, autoresearch improving protocols, and eventually solving open problems. Cryptography joining compression, gas golfing, and kernel optimization on the list of domains being repositioned as autoresearch targets.
https://x.com/iamnotnicola/status/2095084983564063171
A research agenda for generative cryptography, what can we unlock if AI could write cryptography: AI agents engaging in cryptographic interactions, autoresearch improving protocols, and eventually solving open problems. Cryptography joining compression, gas golfing, and kernel optimization on the list of domains being repositioned as autoresearch targets.
#36
@AliyahElys36107
https://x.com/AliyahElys36107/status/2094997782109339757
MimiClaw runs the agent loop itself on a $5-10 ESP32-S3 board, no Raspberry Pi, no Linux, no Node.js, becoming an always-on Telegram AI agent. The models stay remote, but the loop, the part that decides and persists, fits on a microcontroller. The floor for what counts as agent hardware keeps dropping.
https://x.com/AliyahElys36107/status/2094997782109339757
MimiClaw runs the agent loop itself on a $5-10 ESP32-S3 board, no Raspberry Pi, no Linux, no Node.js, becoming an always-on Telegram AI agent. The models stay remote, but the loop, the part that decides and persists, fits on a microcontroller. The floor for what counts as agent hardware keeps dropping.
π‘ Eco Products Radar
Eco Products Radar
Products, tools and frameworks mentioned 3+ times:
- Karpathy's autoresearch - the reference implementation everyone forks: robot arms, GPU tuning, hyperparameter sweeps, Rust-to-assembly golf
- Cursor - cloud agents on customer infrastructure, with the agent loop deliberately kept server-side
- Gemini 3.8 Flash - launched mid-window on an agentic-loop pitch; built a compression algorithm and a 3D game in autonomous loops
- Fable 5.1 - new autoresearch SOTA on Terminal-Bench-Science (52.6 percent, double Fable 5)
- SpeedrunBench (Patronus AI) - agents speedrunning games as a watchable autoresearch benchmark
- Autoresearch Bench - coding agents on open research problems, the anti-saturation benchmark
- Reef / CORAL (CMU, Meta) - open infrastructure for evolving weights plus harness from deployment, and the recommender-tuning loop that compounds
- EvoMap AutoResearch - the open-sourced producer-judge separation for research loops, still circulating
- DeepSeek Harness (dsh) - everything is a plugin, including the agent loop
- Grok Bot - the /loop /goal /swarm vocabulary spreading, plus Obsidian-blackboard coordination designs
- GenLayer - heavy incentive-driven reply cluster pushing open auto-research as a narrative; flagged as promotional
Products, tools and frameworks mentioned 3+ times:
- Karpathy's autoresearch - the reference implementation everyone forks: robot arms, GPU tuning, hyperparameter sweeps, Rust-to-assembly golf
- Cursor - cloud agents on customer infrastructure, with the agent loop deliberately kept server-side
- Gemini 3.8 Flash - launched mid-window on an agentic-loop pitch; built a compression algorithm and a 3D game in autonomous loops
- Fable 5.1 - new autoresearch SOTA on Terminal-Bench-Science (52.6 percent, double Fable 5)
- SpeedrunBench (Patronus AI) - agents speedrunning games as a watchable autoresearch benchmark
- Autoresearch Bench - coding agents on open research problems, the anti-saturation benchmark
- Reef / CORAL (CMU, Meta) - open infrastructure for evolving weights plus harness from deployment, and the recommender-tuning loop that compounds
- EvoMap AutoResearch - the open-sourced producer-judge separation for research loops, still circulating
- DeepSeek Harness (dsh) - everything is a plugin, including the agent loop
- Grok Bot - the /loop /goal /swarm vocabulary spreading, plus Obsidian-blackboard coordination designs
- GenLayer - heavy incentive-driven reply cluster pushing open auto-research as a narrative; flagged as promotional
Comments