Loop Daily: August 5, 2026
The loop conversation split cleanly into hardware and referee this cycle. On one side, autoresearch is landing on owned silicon: a Tenstorrent box ran agents for days and pushed an attention kernel 30% past the native library, DwarfStar squeezed double-digit gains out of DeepSeek V4 Flash on a laptop-class quant, and a dual-GPU owner complains his 500 tok/s rig is hard to keep fed - idle capacity is becoming the argument for more loops, not fewer. On the other side, the judge problem got its clearest articulation yet: a Stanford lecture named the generator-verifier gap (models defend their own reasoning traces), one practitioner found only 18 of 31 self-approved drafts survived human reading, and the fix everyone is converging on is a verifier that sees only the task and the output. In between, the cost of not supervising showed up in numbers: an overnight LangGraph loop burned $47 asking what time it is 847 times, which is why kill-switches, budget routers and loop state kernels dominated the tooling news.
#1
@antnjbert
https://x.com/antnjbert/status/2084377974330343738
Got shipped a TT-QuietBox 2 with 256GB RAM and 4 Blackhole Tensix processors, and built an auto-research platform on top of it. He gave LLM agents a research objective and let them run non-stop for days: making Scaled Dot-Product Attention run as fast as possible on the Blackhole GPU. The agents produced more than 140 hypotheses, ran thousands of jobs, and pushed the kernel ~30% faster than the native library baseline (580k to 405k ns) while keeping PCC above 0.99, with the result headed upstream. He notes the hard part was the harness: fair resource distribution, gating, hypothesis synthesis, avoiding duplicate jobs, and preventing cheating.
https://x.com/antnjbert/status/2084377974330343738
Got shipped a TT-QuietBox 2 with 256GB RAM and 4 Blackhole Tensix processors, and built an auto-research platform on top of it. He gave LLM agents a research objective and let them run non-stop for days: making Scaled Dot-Product Attention run as fast as possible on the Blackhole GPU. The agents produced more than 140 hypotheses, ran thousands of jobs, and pushed the kernel ~30% faster than the native library baseline (580k to 405k ns) while keeping PCC above 0.99, with the result headed upstream. He notes the hard part was the harness: fair resource distribution, gating, hypothesis synthesis, avoiding duplicate jobs, and preventing cheating.
#2
@orvi_onethread
https://x.com/orvi_onethread/status/2084405664596758790
Left a LangGraph agent running overnight and woke up to a $47 bill: 847 GPT-4o calls answering the same trivial question over 8 hours, with no kill-switch and no budget; an earlier daytime incident cost $300 in one afternoon. His point: most observability tools only chart the disaster after the money is gone. So he built and open-sourced baar-core, a local pre-flight kill-switch that estimates cost before every LLM call and raises a local exception when budget runs out, plus semantic complexity routing that scores each task and picks the cheapest capable model. Benchmarks show 84-94% cost reduction while still completing useful work.
https://x.com/orvi_onethread/status/2084405664596758790
Left a LangGraph agent running overnight and woke up to a $47 bill: 847 GPT-4o calls answering the same trivial question over 8 hours, with no kill-switch and no budget; an earlier daytime incident cost $300 in one afternoon. His point: most observability tools only chart the disaster after the money is gone. So he built and open-sourced baar-core, a local pre-flight kill-switch that estimates cost before every LLM call and raises a local exception when budget runs out, plus semantic complexity routing that scores each task and picks the cheapest capable model. Benchmarks show 84-94% cost reduction while still completing useful work.
#3
@VaibhavSisinty
https://x.com/VaibhavSisinty/status/2084304624421605461
Recap of a Reddit user who built a rough GTA 6-style game using Claude and Matt Shumer's Gauntlet loop. He warmed up by generating a playable Worms Armageddon clone from a single prompt, then pointed the loop at GTA 6: the first attempt stalled after generating a static 3D world, but after more iterations and feedback, 22 hours and 86 AI agents later a rough but playable 3D open world emerged. The breakthrough was teaching Claude to understand the game through structured data instead of video frames. One person, no game engine, no team - just a loop.
https://x.com/VaibhavSisinty/status/2084304624421605461
Recap of a Reddit user who built a rough GTA 6-style game using Claude and Matt Shumer's Gauntlet loop. He warmed up by generating a playable Worms Armageddon clone from a single prompt, then pointed the loop at GTA 6: the first attempt stalled after generating a static 3D world, but after more iterations and feedback, 22 hours and 86 AI agents later a rough but playable 3D open world emerged. The breakthrough was teaching Claude to understand the game through structured data instead of video frames. One person, no game engine, no team - just a loop.
#4
@askalphaxiv
https://x.com/askalphaxiv/status/2084190906199282138
alphaXiv introduced Qwen3.8-Max support for autoresearch and shared early results: the model reproduced results from the recent Explorative Modeling paper, then designed a small interpretability experiment on its own to understand how XMs use their noise inputs. On Fashion-MNIST it trained held-out 2D probes at successive checkpoints to visualize which garment different noise vectors would generate, finding that as exploration increased, the destinations became easier to represent with a linear 2D map.
https://x.com/askalphaxiv/status/2084190906199282138
alphaXiv introduced Qwen3.8-Max support for autoresearch and shared early results: the model reproduced results from the recent Explorative Modeling paper, then designed a small interpretability experiment on its own to understand how XMs use their noise inputs. On Fashion-MNIST it trained held-out 2D probes at successive checkpoints to visualize which garment different noise vectors would generate, finding that as exploration increased, the destinations became easier to represent with a linear 2D map.
#5
@smith42mike
https://x.com/smith42mike/status/2084305808557240414
An astronomer ran an autoresearch loop in pi over the weekend and sped up multimodal universe crossmatching by a factor of 2.2x - while he was off on a hike. He says it was so simple he wonders how quickly science will change once this flywheel starts turning. A clean example of autoresearch quietly escaping into real scientific computing.
https://x.com/smith42mike/status/2084305808557240414
An astronomer ran an autoresearch loop in pi over the weekend and sped up multimodal universe crossmatching by a factor of 2.2x - while he was off on a hike. He says it was so simple he wonders how quickly science will change once this flywheel starts turning. A clean example of autoresearch quietly escaping into real scientific computing.
#6
@ivanfioravanti
https://x.com/ivanfioravanti/status/2084179486946308238
Running DwarfStar autoresearch against DeepSeek V4 Flash 0731 in mxfp4 and posting the scoreboard: prefill +10.87% and decode +9.5% so far. After trying GLM 5.2 and Kimi K3 as the driving models he went back to GPT 5.6 Sol, which is delivering the best optimization results, and he plans to keep pushing while waiting for the mxfp4 branch to merge. He floats the idea of a community ds4-flash optimization challenge.
https://x.com/ivanfioravanti/status/2084179486946308238
Running DwarfStar autoresearch against DeepSeek V4 Flash 0731 in mxfp4 and posting the scoreboard: prefill +10.87% and decode +9.5% so far. After trying GLM 5.2 and Kimi K3 as the driving models he went back to GPT 5.6 Sol, which is delivering the best optimization results, and he plans to keep pushing while waiting for the mxfp4 branch to merge. He floats the idea of a community ds4-flash optimization challenge.
#7
@thegomezdude
https://x.com/thegomezdude/status/2084383633117253977
A PostHog engineer describes shipping Code's Autoresearch mode, which he calls the coolest feature he's built: you spawn a cloud task that runs an autonomous experimentation loop against a metric you pick. It instruments the codebase to measure the metric, establishes a baseline, then iterates changes - keeping improvements and discarding regressions. Autoresearch as a product feature inside an analytics platform rather than a research toy.
https://x.com/thegomezdude/status/2084383633117253977
A PostHog engineer describes shipping Code's Autoresearch mode, which he calls the coolest feature he's built: you spawn a cloud task that runs an autonomous experimentation loop against a metric you pick. It instruments the codebase to measure the metric, establishes a baseline, then iterates changes - keeping improvements and discarding regressions. Autoresearch as a product feature inside an analytics platform rather than a research toy.
#8
@leonardoalt
https://x.com/leonardoalt/status/2084360282453786898
The Lean rewrite of powdr's autoprecompiles core optimizer is now shipped upstream, replacing the original Rust code - safer, with better optimization metrics and faster runtime. He credits autoresearch for the work and calls the resulting spec beautiful. Formal-verification-grade code produced by an autonomous loop making it into production infrastructure.
https://x.com/leonardoalt/status/2084360282453786898
The Lean rewrite of powdr's autoprecompiles core optimizer is now shipped upstream, replacing the original Rust code - safer, with better optimization metrics and faster runtime. He credits autoresearch for the work and calls the resulting spec beautiful. Formal-verification-grade code produced by an autonomous loop making it into production infrastructure.
#9
@yume_arasaki
https://x.com/yume_arasaki/status/2084295248868725225
A detailed field report on the weekend DeepSeek V4 Flash 0731 collapsed from datacenter-scale to hardware you own: recipes for dual GB10 boxes just worked (including a production 2x-Spark setup with an Autoresearch component), single DGX Spark runs appeared within days, and DwarfStar made it fit on a 128GB laptop. The author got 82 tok/s decode with 80% speculative acceptance and 327K live context on launch night, and highlights that a Hermes harness run produced the best output files of any harness tested. His thesis: the frontier stopped being something you rent and became something you own.
https://x.com/yume_arasaki/status/2084295248868725225
A detailed field report on the weekend DeepSeek V4 Flash 0731 collapsed from datacenter-scale to hardware you own: recipes for dual GB10 boxes just worked (including a production 2x-Spark setup with an Autoresearch component), single DGX Spark runs appeared within days, and DwarfStar made it fit on a 128GB laptop. The author got 82 tok/s decode with 80% speculative acceptance and 327K live context on launch night, and highlights that a Hermes harness run produced the best output files of any harness tested. His thesis: the frontier stopped being something you rent and became something you own.
#10
@petergyang
https://x.com/petergyang/status/2084289426012897433
Six takeaways from an interview with Nous Research co-founder karan4d on Hermes Agent: the personal part of a personal agent is the memory and skills, not the model; use separate agents to do work and evaluate it because 'you're absolutely right' is reward hacking; a self-improving agent needs to clean up after itself, which Hermes Curator does by archiving stale skills; and go weird - karan uses Hermes to mod Chao Garden inside Sonic Adventure 2. Practical operating doctrine for self-improving agents from someone who builds them.
https://x.com/petergyang/status/2084289426012897433
Six takeaways from an interview with Nous Research co-founder karan4d on Hermes Agent: the personal part of a personal agent is the memory and skills, not the model; use separate agents to do work and evaluate it because 'you're absolutely right' is reward hacking; a self-improving agent needs to clean up after itself, which Hermes Curator does by archiving stale skills; and go weird - karan uses Hermes to mod Chao Garden inside Sonic Adventure 2. Practical operating doctrine for self-improving agents from someone who builds them.
#11
@undefinedKi
https://x.com/undefinedKi/status/2084381268620329153
Why the review step in your agent loop almost never catches anything: Azalia Mirhoseini (Anthropic/DeepMind alum) named it in a Stanford lecture - models stay attached to their own reasoning traces even when better traces are available, so a reviewer sharing context with the writer just defends the author's choices. She calls it the generator-verifier gap. The post pairs it with a practitioner's numbers: 40 drafts, 31 passed self-review, only 18 held up to hand-reading. Fix: run verification as a separate call that sees only the task and output, with its own rubric, returning a verdict and never an edit.
https://x.com/undefinedKi/status/2084381268620329153
Why the review step in your agent loop almost never catches anything: Azalia Mirhoseini (Anthropic/DeepMind alum) named it in a Stanford lecture - models stay attached to their own reasoning traces even when better traces are available, so a reviewer sharing context with the writer just defends the author's choices. She calls it the generator-verifier gap. The post pairs it with a practitioner's numbers: 40 drafts, 31 passed self-review, only 18 held up to hand-reading. Fix: run verification as a separate call that sees only the task and output, with its own rubric, returning a verdict and never an edit.
#12
@nykdotdev
https://x.com/nykdotdev/status/2084224971069591575
A framework for LLM trading agents: one agent loop cannot safely run on two clocks. Open-ended reasoning must stay before the capital boundary, not inside an irreversible order path - the slow clock builds evidence while the fast clock executes only promoted intent against current state. He notes only 1 of 19 closed-loop trading studies reported an explicit transaction-cost model, and prescribes four gates: pin the model and prompt, rebuild orders from current state, give submissions stable identity, and reconcile fills before acting again.
https://x.com/nykdotdev/status/2084224971069591575
A framework for LLM trading agents: one agent loop cannot safely run on two clocks. Open-ended reasoning must stay before the capital boundary, not inside an irreversible order path - the slow clock builds evidence while the fast clock executes only promoted intent against current state. He notes only 1 of 19 closed-loop trading studies reported an explicit transaction-cost model, and prescribes four gates: pin the model and prompt, rebuild orders from current state, give submissions stable identity, and reconcile fills before acting again.
#13
@tierfour_
https://x.com/tierfour_/status/2084328954295439688
Notes from a conversation with an AWS senior applied scientist on coding agents vs tools agents: tool invocations dump entire outputs back into context and burn tokens, while code agents make function calls and pass structured objects like DataFrames straight to the next step. The payoff he points to is auto-research: agents ran roughly four hundred experiments in a couple of days, finding optimizations a human team would have missed, because they never get fatigued. The bottleneck in experimentation used to be the scientist; increasingly it is just compute.
https://x.com/tierfour_/status/2084328954295439688
Notes from a conversation with an AWS senior applied scientist on coding agents vs tools agents: tool invocations dump entire outputs back into context and burn tokens, while code agents make function calls and pass structured objects like DataFrames straight to the next step. The payoff he points to is auto-research: agents ran roughly four hundred experiments in a couple of days, finding optimizations a human team would have missed, because they never get fatigued. The bottleneck in experimentation used to be the scientist; increasingly it is just compute.
#14
@TrevorLongino
https://x.com/TrevorLongino/status/2084307676041777306
Inspired mostly by the name of Karpathy's auto-research tool, he gave an agent a harness that researches a question and automatically pits two models against each other to construct the steelman argument for the answer. The adversarial-research setup now saves him about an hour a day. A small personal example of the debate-as-verification pattern actually paying rent.
https://x.com/TrevorLongino/status/2084307676041777306
Inspired mostly by the name of Karpathy's auto-research tool, he gave an agent a harness that researches a question and automatically pits two models against each other to construct the steelman argument for the answer. The adversarial-research setup now saves him about an hour a day. A small personal example of the debate-as-verification pattern actually paying rent.
#15
@ottogin1
https://x.com/ottogin1/status/2084280901869998547
His running comparison of frontier LLMs on auto-research tasks now charts performance per dollar of API spend, not just per unit of time - you can watch each model climb the metric in terms of money burned. A regularly updated public leaderboard that treats cost-efficiency as a first-class axis for autoresearch, right as model routing and budget control become the practical bottleneck.
https://x.com/ottogin1/status/2084280901869998547
His running comparison of frontier LLMs on auto-research tasks now charts performance per dollar of API spend, not just per unit of time - you can watch each model climb the metric in terms of money burned. A regularly updated public leaderboard that treats cost-efficiency as a first-class axis for autoresearch, right as model routing and budget control become the practical bottleneck.
#16
@haydonryan
https://x.com/haydonryan/status/2084279308479008852
Pushback on 'local AI isn't worth it': his payback period versus API pricing is 3.25 years, and his real problem is keeping the dual-GPU monster rig fed - it peaks above 500 tokens/sec in parallel and even multiple simultaneous projects can't saturate it, especially overnight. His conclusion: he needs to run more autoresearch loops. Owned compute turning idle capacity into a reason to automate research.
https://x.com/haydonryan/status/2084279308479008852
Pushback on 'local AI isn't worth it': his payback period versus API pricing is 3.25 years, and his real problem is keeping the dual-GPU monster rig fed - it peaks above 500 tokens/sec in parallel and even multiple simultaneous projects can't saturate it, especially overnight. His conclusion: he needs to run more autoresearch loops. Owned compute turning idle capacity into a reason to automate research.
#17
@tazr_dev
https://x.com/tazr_dev/status/2084374299373396103
A simple cue for when to spin up an autoresearch loop, credited to 0xSero: the moment you catch yourself thinking 'that's really interesting, but I can't get to it this month' - that backlog item is exactly what the loop is for. Turning the personal project graveyard into a queue for autonomous agents.
https://x.com/tazr_dev/status/2084374299373396103
A simple cue for when to spin up an autoresearch loop, credited to 0xSero: the moment you catch yourself thinking 'that's really interesting, but I can't get to it this month' - that backlog item is exactly what the loop is for. Turning the personal project graveyard into a queue for autonomous agents.
#18
@tazr_dev
https://x.com/tazr_dev/status/2084382179342401718
A snapshot of the loop-harness market churn from one practitioner: he switched this week from Shopify's pi-autoresearch to pi-multiloop, and is also planning to try /goal directly in the codex app. Users are actively comparison-shopping loop harnesses the way they shopped coding agents a year ago.
https://x.com/tazr_dev/status/2084382179342401718
A snapshot of the loop-harness market churn from one practitioner: he switched this week from Shopify's pi-autoresearch to pi-multiloop, and is also planning to try /goal directly in the codex app. Users are actively comparison-shopping loop harnesses the way they shopped coding agents a year ago.
#19
@CobusGreylingZA
https://x.com/CobusGreylingZA/status/2084202028859834513
He created a loop engineering repo and watched it hit 10k GitHub stars without knowing how it got promoted. The idea: let someone create an agentic loop without installing a bigger AI agent framework. He runs loops daily and likes the level of control and supervision they give - minimal loop tooling beating heavyweight frameworks.
https://x.com/CobusGreylingZA/status/2084202028859834513
He created a loop engineering repo and watched it hit 10k GitHub stars without knowing how it got promoted. The idea: let someone create an agentic loop without installing a bigger AI agent framework. He runs loops daily and likes the level of control and supervision they give - minimal loop tooling beating heavyweight frameworks.
#20
@cozybearlog
https://x.com/cozybearlog/status/2084392176533037285
Commentary on a benchmark jump from 74% to 96%: prompts still helped, but the agentic loop - execute, inspect, revise - is what moved the needle. His sharper point: we keep measuring success per prompt when the real unit of work is per loop, and iteration count should be reported as the actual cost driver.
https://x.com/cozybearlog/status/2084392176533037285
Commentary on a benchmark jump from 74% to 96%: prompts still helped, but the agentic loop - execute, inspect, revise - is what moved the needle. His sharper point: we keep measuring success per prompt when the real unit of work is per loop, and iteration count should be reported as the actual cost driver.
#21
@sabeshbharathi
https://x.com/sabeshbharathi/status/2084216607585272205
At MLX India's community meetup at Apple's Bengaluru Developer Center, he showcased running Prism's Bonsai 27B model in an agentic loop directly on an iPhone. The event covered designing models for the Apple Neural Engine and self-improving image generation with MLX. An agentic loop running on a phone's neural engine is a data point for how far down the hardware stack loops are reaching.
https://x.com/sabeshbharathi/status/2084216607585272205
At MLX India's community meetup at Apple's Bengaluru Developer Center, he showcased running Prism's Bonsai 27B model in an agentic loop directly on an iPhone. The event covered designing models for the Apple Neural Engine and self-improving image generation with MLX. An agentic loop running on a phone's neural engine is a data point for how far down the hardware stack loops are reaching.
#22
@PhillipsColinG
https://x.com/PhillipsColinG/status/2084326597809578375
He's building an agentic loop harness he originally called grok2grok: using Grok Build to remotely manage a bidirectional agentic loop across multiple host machines, not just his local box. For fun he renamed the project Secret Agent Man. Multi-machine loop orchestration as a hobby project.
https://x.com/PhillipsColinG/status/2084326597809578375
He's building an agentic loop harness he originally called grok2grok: using Grok Build to remotely manage a bidirectional agentic loop across multiple host machines, not just his local box. For fun he renamed the project Secret Agent Man. Multi-machine loop orchestration as a hobby project.
#23
@status_effects
https://x.com/status_effects/status/2084135844135522627
He had Claude building its own NetHack harness for game-playing autoresearch and says it was going very well - he only stopped because he needed the tokens for other work. Game harness autoresearch as a casual weekend experiment, rationed by token budget rather than difficulty.
https://x.com/status_effects/status/2084135844135522627
He had Claude building its own NetHack harness for game-playing autoresearch and says it was going very well - he only stopped because he needed the tokens for other work. Game harness autoresearch as a casual weekend experiment, rationed by token budget rather than difficulty.
#24
@ShreyashkarLal
https://x.com/ShreyashkarLal/status/2084219986831356296
Keeping track of agent-led research and experiments has become harder as autoresearch loops multiply, so he built autoexp - a local-first experimentation workspace for AI agents. Tooling for the bookkeeping layer of autoresearch: when the agents run the experiments, humans still need a place where the record lives.
https://x.com/ShreyashkarLal/status/2084219986831356296
Keeping track of agent-led research and experiments has become harder as autoresearch loops multiply, so he built autoexp - a local-first experimentation workspace for AI agents. Tooling for the bookkeeping layer of autoresearch: when the agents run the experiments, humans still need a place where the record lives.
#25
@hanghuang_
https://x.com/hanghuang_/status/2084367102119403708
InsForge traced a customer's intermittent retail label-printing failures to stale connections reused after PostgREST closed them, then shipped recovery logic that recognizes the pattern and retries safely. In an 80-agent test with 240 jobs, 182 automatic replays rescued about 93% of transport resets and no job was lost or duplicated. They frame it as the start of self-improving infrastructure: a backend that catches the failure, traces the cause, validates the fix, and ships it.
https://x.com/hanghuang_/status/2084367102119403708
InsForge traced a customer's intermittent retail label-printing failures to stale connections reused after PostgREST closed them, then shipped recovery logic that recognizes the pattern and retries safely. In an 80-agent test with 240 jobs, 182 automatic replays rescued about 93% of transport resets and no job was lost or duplicated. They frame it as the start of self-improving infrastructure: a backend that catches the failure, traces the cause, validates the fix, and ships it.
#26
@JoinEdgeCity
https://x.com/JoinEdgeCity/status/2084356495886487669
Herbie Bradley is building an AI platform that automates enterprise system transformations, starting with migrating legacy C and C++ to Rust. In four weeks: a self-improving agent scaffold showing a 10% performance gain, a $150K pipeline, and $35K in new angel checks. Self-improving migration loops as a fundable business, not just a demo.
https://x.com/JoinEdgeCity/status/2084356495886487669
Herbie Bradley is building an AI platform that automates enterprise system transformations, starting with migrating legacy C and C++ to Rust. In four weeks: a self-improving agent scaffold showing a 10% performance gain, a $150K pipeline, and $35K in new angel checks. Self-improving migration loops as a fundable business, not just a demo.
#27
@ZhihuFrontier
https://x.com/ZhihuFrontier/status/2084201996954022228
Summary of a 149-page survey from Renmin University covering nearly 1,000 studies: long-horizon intelligence is a property of the entire Model-Harness system, not the model alone. Failures cluster into goal drift and error accumulation, context corruption, and sparse rewards with irreversible actions. The control plane has moved from prompt engineering to context engineering to runtime harnesses, and the survey defines three capability levels - within-window reasoning, cross-session state, and learning across task streams. Notably: production permissions and safety boundaries live in the harness, not model weights.
https://x.com/ZhihuFrontier/status/2084201996954022228
Summary of a 149-page survey from Renmin University covering nearly 1,000 studies: long-horizon intelligence is a property of the entire Model-Harness system, not the model alone. Failures cluster into goal drift and error accumulation, context corruption, and sparse rewards with irreversible actions. The control plane has moved from prompt engineering to context engineering to runtime harnesses, and the survey defines three capability levels - within-window reasoning, cross-session state, and learning across task streams. Notably: production permissions and safety boundaries live in the harness, not model weights.
#28
@adidshaft
https://x.com/adidshaft/status/2084230747121197266
A measured read on Qwen3.8-Max's agent claims: it reportedly operated an autonomous coding system for ~16 days (265 commits, 127 PRs), spent ~125 hours reproducing a research paper - 7,600 lines of code, 1,100+ actions, 33 GPU training rounds - then tested 18 of its own improvement ideas and beat the paper's method by 2.7 points on AIME24. He keeps doubt in frame: most numbers are vendor-run, the long runs test the harness as much as the model, and nothing is disclosed about intervention rate or cost. The open-weight release should make it easier to judge.
https://x.com/adidshaft/status/2084230747121197266
A measured read on Qwen3.8-Max's agent claims: it reportedly operated an autonomous coding system for ~16 days (265 commits, 127 PRs), spent ~125 hours reproducing a research paper - 7,600 lines of code, 1,100+ actions, 33 GPU training rounds - then tested 18 of its own improvement ideas and beat the paper's method by 2.7 points on AIME24. He keeps doubt in frame: most numbers are vendor-run, the long runs test the harness as much as the model, and nothing is disclosed about intervention rate or cost. The open-weight release should make it easier to judge.
#29
@HyperAI_News
https://x.com/HyperAI_News/status/2084210071932907982
NVIDIA's NOOA (Object-Oriented Agents) takes a stance: an agent is just a Python object. Methods are actions, fields are state, docstrings are prompts, type annotations are contracts; methods whose body is '...' get completed at runtime by an LLM-driven agent loop while normal methods stay deterministic. It holds up on SWE-bench Verified and Terminal-Bench 2.0, and on ARC-AGI-3 compresses a multi-agent world-model system into a single agent with a one-page skill while advancing the score-cost Pareto frontier.
https://x.com/HyperAI_News/status/2084210071932907982
NVIDIA's NOOA (Object-Oriented Agents) takes a stance: an agent is just a Python object. Methods are actions, fields are state, docstrings are prompts, type annotations are contracts; methods whose body is '...' get completed at runtime by an LLM-driven agent loop while normal methods stay deterministic. It holds up on SWE-bench Verified and Terminal-Bench 2.0, and on ARC-AGI-3 compresses a multi-agent world-model system into a single agent with a one-page skill while advancing the score-cost Pareto frontier.
#30
@emadgnia
https://x.com/emadgnia/status/2084169729946562898
An open-source 'Ralph playbook' for autonomous AI coding dropped, and his observation is the interesting part: the actual agent loop - plan, execute, verify, retry - used to be everyone's private tuning. Now it's a forkable artifact instead of a competitive edge. The loop itself is commoditizing.
https://x.com/emadgnia/status/2084169729946562898
An open-source 'Ralph playbook' for autonomous AI coding dropped, and his observation is the interesting part: the actual agent loop - plan, execute, verify, retry - used to be everyone's private tuning. Now it's a forkable artifact instead of a competitive edge. The loop itself is commoditizing.
#31
@talwar_divyam
https://x.com/talwar_divyam/status/2084186611986915611
A practical gotcha for long agent loops on Grok 4.5: one missing field, prompt_cache_key, can make a long loop land cold. It gives the conversation server affinity - without it, the same prefix can miss the warm cache and repay full input price. Cache-affinity as a first-class knob in loop economics.
https://x.com/talwar_divyam/status/2084186611986915611
A practical gotcha for long agent loops on Grok 4.5: one missing field, prompt_cache_key, can make a long loop land cold. It gives the conversation server affinity - without it, the same prefix can miss the warm cache and repay full input price. Cache-affinity as a first-class knob in loop economics.
#32
@Hevalon
https://x.com/Hevalon/status/2084254940810063966
An agent loop that passes every test it has can run seven times slower the moment it shares a cluster, with nothing inside the loop changed. A pointer to the systems reality underneath agentic workloads: co-tenancy and infrastructure noise dominate once loops leave the laptop.
https://x.com/Hevalon/status/2084254940810063966
An agent loop that passes every test it has can run seven times slower the moment it shares a cluster, with nothing inside the loop changed. A pointer to the systems reality underneath agentic workloads: co-tenancy and infrastructure noise dominate once loops leave the laptop.
#33
@NiteshTechAI
https://x.com/NiteshTechAI/status/2084308350674534701
DeepTutor is an AI study workspace where tutoring, quizzes, research, visualization and mastery tracking all run on one agent loop, with RAG over your own books and notes via LlamaIndex, GraphRAG and LightRAG, live Claude Code or Codex consulted as subagents, three-layer inspectable memory, and MCP plus installable community skills. Over 27,000 GitHub stars, Apache-2.0. The single-loop-many-modes pattern applied to studying.
https://x.com/NiteshTechAI/status/2084308350674534701
DeepTutor is an AI study workspace where tutoring, quizzes, research, visualization and mastery tracking all run on one agent loop, with RAG over your own books and notes via LlamaIndex, GraphRAG and LightRAG, live Claude Code or Codex consulted as subagents, three-layer inspectable memory, and MCP plus installable community skills. Over 27,000 GitHub stars, Apache-2.0. The single-loop-many-modes pattern applied to studying.
#34
@Dinosn
https://x.com/Dinosn/status/2084230269481963925
A lightweight loop-engineering state kernel for long-running AI agent teams: agent-loop agnostic across Codex, Claude Code and other coding agents, with durable goals, quota-aware auto-wake, executable todos, evidence logs, and verifiable handoffs. Infrastructure for keeping fleets of loops honest across restarts and quota resets.
https://x.com/Dinosn/status/2084230269481963925
A lightweight loop-engineering state kernel for long-running AI agent teams: agent-loop agnostic across Codex, Claude Code and other coding agents, with durable goals, quota-aware auto-wake, executable todos, evidence logs, and verifiable handoffs. Infrastructure for keeping fleets of loops honest across restarts and quota resets.
#35
@deepmatmul
https://x.com/deepmatmul/status/2084401228767957299
From someone running autoresearch benchmarks: the human-plus-agent outcome distribution far exceeds either alone - even very high-level, almost mundane human guidance sprinkled into a loop produces outsized outcomes. An argument that the best autoresearch results are centaur runs, not fully hands-off ones.
https://x.com/deepmatmul/status/2084401228767957299
From someone running autoresearch benchmarks: the human-plus-agent outcome distribution far exceeds either alone - even very high-level, almost mundane human guidance sprinkled into a loop produces outsized outcomes. An argument that the best autoresearch results are centaur runs, not fully hands-off ones.
#36
@ShehabAnwer
https://x.com/ShehabAnwer/status/2084390707452637467
His practical variant of builder-breaker loops: force a pure deterministic solver, then run an independent twin-blind verification where the agent codes the solver but is not allowed to grade itself, Karpathy-autoresearch style. He reports this single separation - generation strictly divorced from grading - is a leverage change for reliable multi-step reasoning and efficient token use.
https://x.com/ShehabAnwer/status/2084390707452637467
His practical variant of builder-breaker loops: force a pure deterministic solver, then run an independent twin-blind verification where the agent codes the solver but is not allowed to grade itself, Karpathy-autoresearch style. He reports this single separation - generation strictly divorced from grading - is a leverage change for reliable multi-step reasoning and efficient token use.
#37
@ATPinsights
https://x.com/ATPinsights/status/2084220808151605311
StarlightSearch's CEO on why agents with good memory still fail: retrieval alone is static - an agent must be 'outcome informed', understanding which trajectory of actions leads to success. Signals get lost during retrieval, so retriever-based agents hit a ceiling around 85% success while outcome-informed, self-improving agents push past it. They apply this to domain-specific agents for manufacturing and semiconductors.
https://x.com/ATPinsights/status/2084220808151605311
StarlightSearch's CEO on why agents with good memory still fail: retrieval alone is static - an agent must be 'outcome informed', understanding which trajectory of actions leads to success. Signals get lost during retrieval, so retriever-based agents hit a ceiling around 85% success while outcome-informed, self-improving agents push past it. They apply this to domain-specific agents for manufacturing and semiconductors.
#38
@did0f
https://x.com/did0f/status/2084373821348352240
A content creator's plan to make video production affordable again with an agentic loop: record a talking-head video while walking to the office, drop it from mobile into a specialized session, and not think about it until lunch - if the post-processed result is decent, post it; otherwise, back into the loop. Agentic post-processing as the only way he sees to make regular video output sustainable.
https://x.com/did0f/status/2084373821348352240
A content creator's plan to make video production affordable again with an agentic loop: record a talking-head video while walking to the office, drop it from mobile into a specialized session, and not think about it until lunch - if the post-processed result is decent, post it; otherwise, back into the loop. Agentic post-processing as the only way he sees to make regular video output sustainable.
#39
@betorodriguez
https://x.com/betorodriguez/status/2084392042474655846
Just finished his OS's orchestration architecture: a providerRouter that classifies every incoming message and decides which agent and model handles it, plus an agentic loop that can read files and repos on its own. He calls it the brain deciding who solves what - routing-first architecture arriving in hobby-scale agent projects.
https://x.com/betorodriguez/status/2084392042474655846
Just finished his OS's orchestration architecture: a providerRouter that classifies every incoming message and decides which agent and model handles it, plus an agentic loop that can read files and repos on its own. He calls it the brain deciding who solves what - routing-first architecture arriving in hobby-scale agent projects.
#40
@seanphan
https://x.com/seanphan/status/2084139158638055773
An honest failure report: every time he tries autoresearch it somehow ends up in 'the mediocre loop' - even using the harness from Karpathy's repo. He suggests 'microtuning' is the right term for what actually happens. A useful counterweight to the highlight reels: without the right task framing, loops converge to mediocrity.
https://x.com/seanphan/status/2084139158638055773
An honest failure report: every time he tries autoresearch it somehow ends up in 'the mediocre loop' - even using the harness from Karpathy's repo. He suggests 'microtuning' is the right term for what actually happens. A useful counterweight to the highlight reels: without the right task framing, loops converge to mediocrity.
#41
@vsletten3006
https://x.com/vsletten3006/status/2084121380225007925
A field guide to how every major coding agent forgets: LLM agents solve running out of memory by giving themselves amnesia on purpose - forgetting the 23 files they just edited, denying the commits they made, and gaslighting you about it. Documentation of the memory-management behaviors that make long loops fail in practice.
https://x.com/vsletten3006/status/2084121380225007925
A field guide to how every major coding agent forgets: LLM agents solve running out of memory by giving themselves amnesia on purpose - forgetting the 23 files they just edited, denying the commits they made, and gaslighting you about it. Documentation of the memory-management behaviors that make long loops fail in practice.
#42
@0xblockXBT
https://x.com/0xblockXBT/status/2084326797915861208
Cortex is a fully autonomous CLI engine that takes Hermes-inspired open-source agent foundations further: SQLite FTS5 full-text memory over execution history, a self-improving Markdown skill library, an omni-channel gateway daemon for Telegram and Discord, a self-evolving tool creator that generates Python tools on the fly, and a multi-agent swarm that launches 100 parallel sub-agents for planning, coding, debugging and auditing.
https://x.com/0xblockXBT/status/2084326797915861208
Cortex is a fully autonomous CLI engine that takes Hermes-inspired open-source agent foundations further: SQLite FTS5 full-text memory over execution history, a self-improving Markdown skill library, an omni-channel gateway daemon for Telegram and Discord, a self-evolving tool creator that generates Python tools on the fly, and a multi-agent swarm that launches 100 parallel sub-agents for planning, coding, debugging and auditing.
#43
@mfpiccolo
https://x.com/mfpiccolo/status/2084369827305496885
Vendors describe proactive agentic loops as novel and advanced, but it becomes trivial to write one yourself once you're using the right primitives - his example creates a proactive agentic loop in under 5 minutes using the iii harness, with a guide to implementing various loop types using standard software engineering patterns. The demystification wing of loop engineering.
https://x.com/mfpiccolo/status/2084369827305496885
Vendors describe proactive agentic loops as novel and advanced, but it becomes trivial to write one yourself once you're using the right primitives - his example creates a proactive agentic loop in under 5 minutes using the iii harness, with a guide to implementing various loop types using standard software engineering patterns. The demystification wing of loop engineering.
π‘ Eco Products Radar
Eco Products Radar
Qwen3.8-Max (6) | DeepSeek V4 Flash (5) | Hermes Agent (5) | Claude Code (5) | Karpathy autoresearch (4) | pi / pi-autoresearch / pi-multiloop (4) | DwarfStar ds4 (3) | Codex (3) | Gauntlet (1, viral)
Qwen3.8-Max (6) | DeepSeek V4 Flash (5) | Hermes Agent (5) | Claude Code (5) | Karpathy autoresearch (4) | pi / pi-autoresearch / pi-multiloop (4) | DwarfStar ds4 (3) | Codex (3) | Gauntlet (1, viral)
Comments