Loop Daily: 2026-08-28
Autoresearch stopped being a Karpathy demo this week and started showing up as infrastructure that ships real numbers. A quant exchange ran a Claude agentic loop against its market-data plant for months and cut distribution latency from over a minute to 250ms; a product engineer pointed an agent at his own app's performance metrics and now wakes up to 'treasure' every morning; alphaxiv turned any arXiv paper into a replay-and-beat experiment tree powered by armies of Claude and Codex agents. Two shapes dominate: the finance/ops crowd running autoresearch on backtests and trading loops, and the harness-and-graph crowd arguing that a bare agent loop forgets and stalls, so the real work is the memory and verification structure wrapped around it. The recurring caution, stated bluntly by more than one builder: an autoresearch loop optimizes against your metric at all costs, so a flawed metric gets ruthlessly exploited.
#1
@jaredbroad
https://x.com/jaredbroad/status/2092660263212274167
QuantConnect made its live US equity options and index data feed free, and the interesting part is how they got the latency down. They set up an agentic loop with Claude that had access to their ticker-plant beta environment β it could build, iterate, read the logs. Over a few months and a few dead ends, OPRA distribution latency during peaks dropped from over a minute to 250ms, and those gains carried over to every other asset class, cutting their latencies up to 50%. A rare case of an overnight-agent loop pointed at real infrastructure producing a hard, measurable win.
https://x.com/jaredbroad/status/2092660263212274167
QuantConnect made its live US equity options and index data feed free, and the interesting part is how they got the latency down. They set up an agentic loop with Claude that had access to their ticker-plant beta environment β it could build, iterate, read the logs. Over a few months and a few dead ends, OPRA distribution latency during peaks dropped from over a minute to 250ms, and those gains carried over to every other asset class, cutting their latencies up to 50%. A rare case of an overnight-agent loop pointed at real infrastructure producing a hard, measurable win.
#2
@PremiumGoblin
https://x.com/PremiumGoblin/status/2092463138306204006
A product engineer recreated Karpathy's autoresearch loop for mobile-app performance metrics β a domain where results are hard to verify without large-scale experiments. He runs an agent on a long-running goal to read the codebase and find A/B opportunities, and built a mini experiment platform that simulates thousands of runs locally, logging to a local DB he queries to recreate production perf metrics. Results are directional, not definitive, but give him enough confidence to pursue the agent's best ideas. His line captures why this works: perf is one area needing little alignment β no designs, no data-usage change, mostly invisible to users β and easy to verify, so it's ideal to hand to an autonomous loop.
https://x.com/PremiumGoblin/status/2092463138306204006
A product engineer recreated Karpathy's autoresearch loop for mobile-app performance metrics β a domain where results are hard to verify without large-scale experiments. He runs an agent on a long-running goal to read the codebase and find A/B opportunities, and built a mini experiment platform that simulates thousands of runs locally, logging to a local DB he queries to recreate production perf metrics. Results are directional, not definitive, but give him enough confidence to pursue the agent's best ideas. His line captures why this works: perf is one area needing little alignment β no designs, no data-usage change, mostly invisible to users β and easy to verify, so it's ideal to hand to an autonomous loop.
#3
@askalphaxiv
https://x.com/askalphaxiv/status/2093045986696609829
alphaxiv shipped autoresearch for arXiv papers: replicate and experiment on any paper using an army of Claude and Codex agents. For post-training, your agents can launch concurrent RL runs via tinker while you watch the experiment tree grow. It's live on their OpenResearch platform. This is the clearest example yet of autoresearch as a product rather than a personal script β turning a static paper into a running, branchable experiment.
https://x.com/askalphaxiv/status/2093045986696609829
alphaxiv shipped autoresearch for arXiv papers: replicate and experiment on any paper using an army of Claude and Codex agents. For post-training, your agents can launch concurrent RL runs via tinker while you watch the experiment tree grow. It's live on their OpenResearch platform. This is the clearest example yet of autoresearch as a product rather than a personal script β turning a static paper into a running, branchable experiment.
#4
@RoundtableSpace
https://x.com/RoundtableSpace/status/2092986744568176923
A 9B model called Ornith 1.5 ran a full agentic loop with Wi-Fi off β read three spreadsheets, cross-referenced monthly rollups, and wrote a revenue analysis without a single byte leaving the Mac. Fully air-gapped, doing real analytical work. It's a pointed counter to the assumption that agentic loops need frontier cloud models; a small local model closing a real multi-step analysis loop is its own kind of milestone.
https://x.com/RoundtableSpace/status/2092986744568176923
A 9B model called Ornith 1.5 ran a full agentic loop with Wi-Fi off β read three spreadsheets, cross-referenced monthly rollups, and wrote a revenue analysis without a single byte leaving the Mac. Fully air-gapped, doing real analytical work. It's a pointed counter to the assumption that agentic loops need frontier cloud models; a small local model closing a real multi-step analysis loop is its own kind of milestone.
#5
@sabeshbharathi
https://x.com/sabeshbharathi/status/2092536717287055576
An on-device agentic loop running entirely on the Apple Neural Engine, offline and free. The model accesses HealthKit and MapKit: it fetches the day's steps, figures out the 10k walking goal, calculates the distance needed to close the gap, then calls the maps API to find nearby coffee spots that would get you there. Watching a small model chain HealthKit, arithmetic and a maps call in one agentic loop is a concrete look at where personal on-device agents are heading.
https://x.com/sabeshbharathi/status/2092536717287055576
An on-device agentic loop running entirely on the Apple Neural Engine, offline and free. The model accesses HealthKit and MapKit: it fetches the day's steps, figures out the 10k walking goal, calculates the distance needed to close the gap, then calls the maps API to find nearby coffee spots that would get you there. Watching a small model chain HealthKit, arithmetic and a maps call in one agentic loop is a concrete look at where personal on-device agents are heading.
#6
@charliejhills
https://x.com/charliejhills/status/2092632122888732972
A clean breakdown of Anthropic's four agent-loop types, each handing off more of the job: turn-based (you send the prompt, it stops when done), goal-based (you set the stop condition and turn cap), time-based (an interval you set via /loop), and proactive (event or schedule-triggered via /schedule, moved to the cloud). The load-bearing lesson comes from his own pain: every loop needs a stop condition, and skipping it is what had him burning tokens overnight with Claude critiquing its own work in an endless cycle. The fix was one cap β 'stop after 5 tries.'
https://x.com/charliejhills/status/2092632122888732972
A clean breakdown of Anthropic's four agent-loop types, each handing off more of the job: turn-based (you send the prompt, it stops when done), goal-based (you set the stop condition and turn cap), time-based (an interval you set via /loop), and proactive (event or schedule-triggered via /schedule, moved to the cloud). The load-bearing lesson comes from his own pain: every loop needs a stop condition, and skipping it is what had him burning tokens overnight with Claude critiquing its own work in an endless cycle. The fix was one cap β 'stop after 5 tries.'
#7
@guybedo
https://x.com/guybedo/status/2092308945599975894
A backtesting platform builder added an autoresearch tool to his Edgefound desktop app, and now GPT 5.6 does most of the research by itself and pings him when something interesting shows up. It runs backtests and optimization sweeps on a dual-EPYC box with 1TB RAM. A concrete non-coding autoresearch case in quant finance: the agent runs the research loop autonomously and only surfaces the signal, with the human as the interrupt handler rather than the operator.
https://x.com/guybedo/status/2092308945599975894
A backtesting platform builder added an autoresearch tool to his Edgefound desktop app, and now GPT 5.6 does most of the research by itself and pings him when something interesting shows up. It runs backtests and optimization sweeps on a dual-EPYC box with 1TB RAM. A concrete non-coding autoresearch case in quant finance: the agent runs the research loop autonomously and only surfaces the signal, with the human as the interrupt handler rather than the operator.
#8
@phon_ro
https://x.com/phon_ro/status/2092910308709019756
A genuinely experimental setup: Hermes bots plus autoresearch loops, each with their own coding repo and trading tools, running semi-autonomously and self-evolving. He's considering giving them payment rails for subscriptions they could take on once they've generated enough cash. It's autonomous coding plus trading plus self-directed autoresearch loops, kept deliberately broad to start β an honest look at someone letting agent loops run open-ended to see what emerges.
https://x.com/phon_ro/status/2092910308709019756
A genuinely experimental setup: Hermes bots plus autoresearch loops, each with their own coding repo and trading tools, running semi-autonomously and self-evolving. He's considering giving them payment rails for subscriptions they could take on once they've generated enough cash. It's autonomous coding plus trading plus self-directed autoresearch loops, kept deliberately broad to start β an honest look at someone letting agent loops run open-ended to see what emerges.
#9
@JonasBadalic
https://x.com/JonasBadalic/status/2093036644903297523
A tidy autoresearch result on real code: he pointed Grok at Karpathy's autoresearch doc and told it to use pprof to optimize the program. The loop delivered 61% improvements with a 33% experiment success rate. Go's performance toolchain being clutch in the agentic world is the takeaway β a profiler plus a clear metric turns optimization into an automatable experiment loop.
https://x.com/JonasBadalic/status/2093036644903297523
A tidy autoresearch result on real code: he pointed Grok at Karpathy's autoresearch doc and told it to use pprof to optimize the program. The loop delivered 61% improvements with a 33% experiment success rate. Go's performance toolchain being clutch in the agentic world is the takeaway β a profiler plus a clear metric turns optimization into an automatable experiment loop.
#10
@kadirnardev
https://x.com/kadirnardev/status/2092928073532322133
He started building the fast-kernel library by taking inspiration from Karpathy's autoresearch project: you optimize all the models you want with a single command. First-attempt results attached. Another instance of the autoresearch pattern generalizing beyond the original demo into a reusable optimization tool.
https://x.com/kadirnardev/status/2092928073532322133
He started building the fast-kernel library by taking inspiration from Karpathy's autoresearch project: you optimize all the models you want with a single command. First-attempt results attached. Another instance of the autoresearch pattern generalizing beyond the original demo into a reusable optimization tool.
#11
@marfinxx
https://x.com/marfinxx/status/2092222137926864992
A strong writeup of a Google paper that turns static LLMs into self-improving agents by distilling strategies from both failed and successful trajectories. ReasoningBank stores structured reasoning items (title, description, rationale) that transfer to unseen sites and codebases; MaTTS scales test-time compute via parallel self-contrast rollouts; failures become preventative rules. Validated on WebArena, Mind2Web and SWE-Bench-Verified, it drove a +20% relative success surge while cutting redundant steps 26.9%. The thesis worth keeping: lifelong agents come from distilling failures into reusable reasoning units, not stuffing raw logs into long context.
https://x.com/marfinxx/status/2092222137926864992
A strong writeup of a Google paper that turns static LLMs into self-improving agents by distilling strategies from both failed and successful trajectories. ReasoningBank stores structured reasoning items (title, description, rationale) that transfer to unseen sites and codebases; MaTTS scales test-time compute via parallel self-contrast rollouts; failures become preventative rules. Validated on WebArena, Mind2Web and SWE-Bench-Verified, it drove a +20% relative success surge while cutting redundant steps 26.9%. The thesis worth keeping: lifelong agents come from distilling failures into reusable reasoning units, not stuffing raw logs into long context.
#12
@askalphaxiv
https://x.com/askalphaxiv/status/2092335890198663370
Prime Agent: a self-improving RLM harness that gives agents a persistent Python REPL, recursive subagents, direct communication, and disk-backed memories and skills that survive across trajectories. It achieves self-improvement without weight updates β agents turn experience into reusable state and better future behavior. With Prime Agent, Opus 5 reaches 95.5% on ARC-AGI-3 versus 30.2% with the reference harness. The number is the argument: the harness, not the weights, is doing most of the lifting.
https://x.com/askalphaxiv/status/2092335890198663370
Prime Agent: a self-improving RLM harness that gives agents a persistent Python REPL, recursive subagents, direct communication, and disk-backed memories and skills that survive across trajectories. It achieves self-improvement without weight updates β agents turn experience into reusable state and better future behavior. With Prime Agent, Opus 5 reaches 95.5% on ARC-AGI-3 versus 30.2% with the reference harness. The number is the argument: the harness, not the weights, is doing most of the lifting.
#13
@aiclawbots
https://x.com/aiclawbots/status/2092628136517345414
A real month-long usage report of a self-improving skill on OpenClaw. The ClawHub 'Self Improving Agent' skill by pskoett captures your corrections, tags them, and injects the relevant learnings back into context when a similar task shows up. His verdict after a month: the compounding is real β things he used to correct three times a week he hasn't corrected in the last ten days. A grounded, non-hype data point on whether correction-capture loops actually pay off in daily use.
https://x.com/aiclawbots/status/2092628136517345414
A real month-long usage report of a self-improving skill on OpenClaw. The ClawHub 'Self Improving Agent' skill by pskoett captures your corrections, tags them, and injects the relevant learnings back into context when a similar task shows up. His verdict after a month: the compounding is real β things he used to correct three times a week he hasn't corrected in the last ten days. A grounded, non-hype data point on whether correction-capture loops actually pay off in daily use.
#14
@GeoffreyHuntley
https://x.com/GeoffreyHuntley/status/2092975233556996212
A useful methodological caution from someone shipping LLM systems: he wishes more people didn't lean on the agentic loop 100%, and instead used Temporal-style workflow engines as stages. There's an art to deciding whether to use the LLM loop or a deterministic workflow for a given step β and you can do both, with the magic in combining them correctly. The recurring 'deterministic for the boring 90%, agentic loop for the messy 10%' framing showed up repeatedly in the replies.
https://x.com/GeoffreyHuntley/status/2092975233556996212
A useful methodological caution from someone shipping LLM systems: he wishes more people didn't lean on the agentic loop 100%, and instead used Temporal-style workflow engines as stages. There's an art to deciding whether to use the LLM loop or a deterministic workflow for a given step β and you can do both, with the magic in combining them correctly. The recurring 'deterministic for the boring 90%, agentic loop for the messy 10%' framing showed up repeatedly in the replies.
#15
@atomic_chat_hq
https://x.com/atomic_chat_hq/status/2092759022390632660
A concrete local-agent benchmark: a 1-bit Qwen 3.8 Flash Next (79GB) running on a MacBook Pro M5 Max at 30 tok/s ran an 8-minute agent loop with 6 web searches, 3 Python runs and 5 sourced tables. A real, timed demonstration that a heavily quantized local model can sustain a multi-tool agent loop long enough to do useful research.
https://x.com/atomic_chat_hq/status/2092759022390632660
A concrete local-agent benchmark: a 1-bit Qwen 3.8 Flash Next (79GB) running on a MacBook Pro M5 Max at 30 tok/s ran an 8-minute agent loop with 6 web searches, 3 Python runs and 5 sourced tables. A real, timed demonstration that a heavily quantized local model can sustain a multi-tool agent loop long enough to do useful research.
#16
@bountyAIhunter
https://x.com/bountyAIhunter/status/2092992146231996796
A careful quant-level test of where agent loops actually break. Re-running a 60-task agent set across quantizations, he found the drop at 1-bit isn't slightly worse prose β the model stops closing tool-call JSON on roughly a third of turns, so the agent loop dies before the answer is even wrong. Scores: Q4_K_XL 38/60, IQ4_XS 37/60 down to IQ1_M 24/60. The insight for anyone running local agent loops: JSON-closing reliability, not prose quality, is the failure mode that kills the loop.
https://x.com/bountyAIhunter/status/2092992146231996796
A careful quant-level test of where agent loops actually break. Re-running a 60-task agent set across quantizations, he found the drop at 1-bit isn't slightly worse prose β the model stops closing tool-call JSON on roughly a third of turns, so the agent loop dies before the answer is even wrong. Scores: Q4_K_XL 38/60, IQ4_XS 37/60 down to IQ1_M 24/60. The insight for anyone running local agent loops: JSON-closing reliability, not prose quality, is the failure mode that kills the loop.
#17
@philadelphiafed
https://x.com/philadelphiafed/status/2093074830006305155
The Philadelphia Fed published a working paper titled 'An Auditable AI Agent Loop for Empirical Economics: A Case Study in Forecast Combination.' Autoresearch showing up in a central-bank research shop, with auditability as the headline requirement, is a meaningful signal that the agent-loop pattern is moving into domains where every step has to be traceable and defensible.
https://x.com/philadelphiafed/status/2093074830006305155
The Philadelphia Fed published a working paper titled 'An Auditable AI Agent Loop for Empirical Economics: A Case Study in Forecast Combination.' Autoresearch showing up in a central-bank research shop, with auditability as the headline requirement, is a meaningful signal that the agent-loop pattern is moving into domains where every step has to be traceable and defensible.
#18
@nibzard
https://x.com/nibzard/status/2093099826502050240
A neat autoresearch-flavored workflow: while building a new API, he realized he could mock the whole product from the OpenAPI JSON (itself generated from a working Notion page), feed it to an agent loop to dogfood it, analyze the sessions and iteratively improve the API before implementing anything. He's tasked his agents with extracting it as a separate product. Essentially autoresearch applied to API design β let the loop stress-test and refine the spec before a line of the real thing is written.
https://x.com/nibzard/status/2093099826502050240
A neat autoresearch-flavored workflow: while building a new API, he realized he could mock the whole product from the OpenAPI JSON (itself generated from a working Notion page), feed it to an agent loop to dogfood it, analyze the sessions and iteratively improve the API before implementing anything. He's tasked his agents with extracting it as a separate product. Essentially autoresearch applied to API design β let the loop stress-test and refine the spec before a line of the real thing is written.
π‘ Eco Products Radar
Eco Products Radar
Tools, models and frameworks named 3+ times in today's autoresearch/loop posts.
Claude Code / Codex β the default agent workers people fan out for autoresearch runs.
Karpathy's autoresearch (the doc/repo) β the reference pattern nearly every hill-climbing case cites.
alphaxiv OpenResearch β turns arXiv papers into replayable experiment trees.
tinker (@tinkerapi) β the RL-run launcher behind the post-training autoresearch demos.
Prime Agent β self-improving RLM harness (Opus 5 to 95.5% on ARC-AGI-3) cited across the day.
Temporal β the deterministic workflow engine people pair with the agentic loop for the reliable 90%.
DGX Spark / local Qwen β the hardware and models behind the on-device and air-gapped agent loops.
Tools, models and frameworks named 3+ times in today's autoresearch/loop posts.
Claude Code / Codex β the default agent workers people fan out for autoresearch runs.
Karpathy's autoresearch (the doc/repo) β the reference pattern nearly every hill-climbing case cites.
alphaxiv OpenResearch β turns arXiv papers into replayable experiment trees.
tinker (@tinkerapi) β the RL-run launcher behind the post-training autoresearch demos.
Prime Agent β self-improving RLM harness (Opus 5 to 95.5% on ARC-AGI-3) cited across the day.
Temporal β the deterministic workflow engine people pair with the agentic loop for the reliable 90%.
DGX Spark / local Qwen β the hardware and models behind the on-device and air-gapped agent loops.
Comments