Loop Daily: July 27, 2026
Autoresearch has fully left the codebase. This week it tuned a chess model that beats frontier engines, took a vision model from 25% to 97% on a counting task inside a five-hour budget, squeezed 5% out of a compiler, threw itself at rocket-grade isogrid structures in an hour, and topped an NVIDIA GPU-kernel leaderboard across 235 problems. The loop itself is basically solved plumbing now β the hard part everyone keeps circling back to is the judge. A verifier that catches its own contradiction mid-task, a pytest harness that grades three hidden bugs, an eight-exit checklist for when to STOP a run before it quietly burns $500: the conversation has moved from how to keep a loop alive to how to make it stop cleanly and trust what it hands back. And a quiet second thread runs through all of it β people insisting a used $200 GPU or an 8GB local model can now hold a real 128k agentic loop with no cloud bill attached.
#1
@andreleibovici
https://x.com/andreleibovici/status/2081088714680508903
Built a market-scanning system where thresholds aren't hand-tuned: every scan is stored with 1-to-30-day forward returns and backtested with LightGBM. The whole thing runs on Karpathy-style autoresearch that edits its own code, runs the experiment, and keeps only the version that beats validation. A concrete example of autoresearch pointed at quantitative finance rather than model training.
https://x.com/andreleibovici/status/2081088714680508903
Built a market-scanning system where thresholds aren't hand-tuned: every scan is stored with 1-to-30-day forward returns and backtested with LightGBM. The whole thing runs on Karpathy-style autoresearch that edits its own code, runs the experiment, and keeps only the version that beats validation. A concrete example of autoresearch pointed at quantitative finance rather than model training.
#2
@i_amanchadha
https://x.com/i_amanchadha/status/2080856252687745093
Published a detailed end-to-end primer on autoresearch and the 'meta-harness' idea: autoresearch shouldn't just optimize model weights but the entire system around an LLM, including prompts, retrieval, memory, tools, state, parsers, and control flow. Walks through propose-run-evaluate-repeat loops, editable-code vs frozen-infrastructure, filesystem-based experiment memory, validation gates and Pareto selection, and reward-hacking controls. One of the more complete technical maps of how autonomous research systems actually get built.
https://x.com/i_amanchadha/status/2080856252687745093
Published a detailed end-to-end primer on autoresearch and the 'meta-harness' idea: autoresearch shouldn't just optimize model weights but the entire system around an LLM, including prompts, retrieval, memory, tools, state, parsers, and control flow. Walks through propose-run-evaluate-repeat loops, editable-code vs frozen-infrastructure, filesystem-based experiment memory, validation gates and Pareto selection, and reward-hacking controls. One of the more complete technical maps of how autonomous research systems actually get built.
#3
@papersdatacode
https://x.com/papersdatacode/status/2081160818394034487
Reviewed Arbor, an autoresearch tool that runs the whole loop as a hypothesis tree, and flagged a real limitation: insights only flow up the lineage to ancestors, so sibling branches get compared but never share what they learn. Proposed adding embedding-based edges over the hypothesis descriptions so related nodes in different branches can trade lessons sideways, then measuring how much it helps. A concrete methodology tweak, not hand-waving.
https://x.com/papersdatacode/status/2081160818394034487
Reviewed Arbor, an autoresearch tool that runs the whole loop as a hypothesis tree, and flagged a real limitation: insights only flow up the lineage to ancestors, so sibling branches get compared but never share what they learn. Proposed adding embedding-based edges over the hypothesis descriptions so related nodes in different branches can trade lessons sideways, then measuring how much it helps. A concrete methodology tweak, not hand-waving.
#4
@v_shakthi
https://x.com/v_shakthi/status/2080880337299845522
Broke down NVIDIA's autoresearch workflow on NeMo RL and NeMo Gym. In one published run a Codex agent took a VLM from 25% to 96.9% accuracy on a visual counting task inside a 5-hour budget, building the environment, wiring the data path, running experiments, analyzing errors, and proposing the next direction on its own. Credits three agent skills (session-memory, brev-etiquette, autoresearch) for making agent-led research reproducible instead of forgetting the goal after a context reset.
https://x.com/v_shakthi/status/2080880337299845522
Broke down NVIDIA's autoresearch workflow on NeMo RL and NeMo Gym. In one published run a Codex agent took a VLM from 25% to 96.9% accuracy on a visual counting task inside a 5-hour budget, building the environment, wiring the data path, running experiments, analyzing errors, and proposing the next direction on its own. Credits three agent skills (session-memory, brev-etiquette, autoresearch) for making agent-led research reproducible instead of forgetting the goal after a context reset.
#5
@demirelo
https://x.com/demirelo/status/2081152468667232372
Reported killing several divergences in solidity-lean and improving the Solidus compiler by over 5% through what they call collaborative autoresearch. Small but concrete: the loop found a measurable compiler optimization, not just a demo.
https://x.com/demirelo/status/2081152468667232372
Reported killing several divergences in solidity-lean and improving the Solidus compiler by over 5% through what they call collaborative autoresearch. Small but concrete: the loop found a measurable compiler optimization, not just a demo.
#6
@mov_axbx
https://x.com/mov_axbx/status/2081140812499333304
Built an agent that learns to play Hanabi, a game where you succeed only by discovering a communication protocol over a constrained, low-bandwidth channel. Framed it as in-context learning done before the autoresearch trend, and pointed out the nice property that the output is a legible list of strategies for optimal play, useful and readable for humans rather than a black box.
https://x.com/mov_axbx/status/2081140812499333304
Built an agent that learns to play Hanabi, a game where you succeed only by discovering a communication protocol over a constrained, low-bandwidth channel. Framed it as in-context learning done before the autoresearch trend, and pointed out the nice property that the output is a legible list of strategies for optimal play, useful and readable for humans rather than a black box.
#7
@YuxiangLin_Lum
https://x.com/YuxiangLin_Lum/status/2081047476182888757
Released Auto Debug, an open-source companion to autoresearch: where autoresearch lets agents research for you, Auto Debug lets agents debug for you with breakpoints, live variables, stepping, and runtime hypothesis testing instead of guess-and-patch loops. Supports Claude Code and Codex.
https://x.com/YuxiangLin_Lum/status/2081047476182888757
Released Auto Debug, an open-source companion to autoresearch: where autoresearch lets agents research for you, Auto Debug lets agents debug for you with breakpoints, live variables, stepping, and runtime hypothesis testing instead of guess-and-patch loops. Supports Claude Code and Codex.
#8
@sashinmeena
https://x.com/sashinmeena/status/2081046303447064955
Showed StrikeRobot's SR Platform going from basic to high-fidelity, Isaac-Sim-compatible training scenes in a month. The real signal is the agentic loop behind them, tool calling plus self-evaluation plus iterative refinement running continuously, so the simulation worlds and the robot intelligence improve each other and the sim-to-real gap narrows.
https://x.com/sashinmeena/status/2081046303447064955
Showed StrikeRobot's SR Platform going from basic to high-fidelity, Isaac-Sim-compatible training scenes in a month. The real signal is the agentic loop behind them, tool calling plus self-evaluation plus iterative refinement running continuously, so the simulation worlds and the robot intelligence improve each other and the sim-to-real gap narrows.
#9
@beamnxw
https://x.com/beamnxw/status/2080957020090380309
Walked through TeaRAG, an agentic-RAG design that compresses on both retrieval and reasoning: triplets plus an association graph plus personalized PageRank cut tokens per retrieval, and a process-aware DPO loop shortens reasoning steps. Reports +4%/+2% exact match with 61%/59% fewer output tokens on Llama3-8B and Qwen2.5-14B, arguing you can't ship agentic RAG in production without joint compression.
https://x.com/beamnxw/status/2080957020090380309
Walked through TeaRAG, an agentic-RAG design that compresses on both retrieval and reasoning: triplets plus an association graph plus personalized PageRank cut tokens per retrieval, and a process-aware DPO loop shortens reasoning steps. Reports +4%/+2% exact match with 61%/59% fewer output tokens on Llama3-8B and Qwen2.5-14B, arguing you can't ship agentic RAG in production without joint compression.
#10
@0xPascual
https://x.com/0xPascual/status/2081065385940447294
Described a solo quant trader bypassing the traditional brokerage advisory desk by exposing Robinhood's native MCP endpoints directly to an autonomous agentic loop. The agent parses real-time order books over JSON-RPC, computes portfolio variance across asset classes, and executes rebalancing orders through a headless Claude API integration for cents per run, an agentic trading loop operating outside the usual wealth-management stack.
https://x.com/0xPascual/status/2081065385940447294
Described a solo quant trader bypassing the traditional brokerage advisory desk by exposing Robinhood's native MCP endpoints directly to an autonomous agentic loop. The agent parses real-time order books over JSON-RPC, computes portfolio variance across asset classes, and executes rebalancing orders through a headless Claude API integration for cents per run, an agentic trading loop operating outside the usual wealth-management stack.
#11
@sudoingX
https://x.com/sudoingX/status/2081069142493499431
Pushed back on the idea that a small local model is a phone toy: the point of the 8GB run is that it holds a full 128k-token agentic loop, which puts it past toy territory into real unattended-work range. A data point in the ongoing push to run capable agent loops entirely on local hardware.
https://x.com/sudoingX/status/2081069142493499431
Pushed back on the idea that a small local model is a phone toy: the point of the 8GB run is that it holds a full 128k-token agentic loop, which puts it past toy territory into real unattended-work range. A data point in the ongoing push to run capable agent loops entirely on local hardware.
#12
@TRSTNGLRD
https://x.com/TRSTNGLRD/status/2081056909575291201
Attempted a hard mechanical-design task, an isogrid structure, with Leap71 PicoGK, ANSYS, and an army of Kimi-K3 sub-agents in Cursor over about an hour of auto-research. Honest verdict: auto-research is still weak at multi-objective optimization (roughly 80% slop, 20% rational), but it produced a decent one-shot wireframe and the author is now isolating the bottlenecks. A candid look at where autonomous research loops break on real engineering.
https://x.com/TRSTNGLRD/status/2081056909575291201
Attempted a hard mechanical-design task, an isogrid structure, with Leap71 PicoGK, ANSYS, and an army of Kimi-K3 sub-agents in Cursor over about an hour of auto-research. Honest verdict: auto-research is still weak at multi-objective optimization (roughly 80% slop, 20% rational), but it produced a decent one-shot wireframe and the author is now isolating the bottlenecks. A candid look at where autonomous research loops break on real engineering.
#13
@amir_mir93
https://x.com/amir_mir93/status/2080908349550297416
Placed 1st overall in NVIDIA's SOL-ExecBench competition across 4 tracks and 235 problems after three months, crediting what they learned about recursive self-improvement, auto-research, and AI-powered GPU kernel tuning. A concrete competitive result from pointing autoresearch at GPU kernel optimization.
https://x.com/amir_mir93/status/2080908349550297416
Placed 1st overall in NVIDIA's SOL-ExecBench competition across 4 tracks and 235 problems after three months, crediting what they learned about recursive self-improvement, auto-research, and AI-powered GPU kernel tuning. A concrete competitive result from pointing autoresearch at GPU kernel optimization.
#14
@jednapcela
https://x.com/jednapcela/status/2080914051832430862
Described a production multi-agent workflow where each model has an orthogonal role: Claude as architect and orchestrator with final veto, Gemini/Gemma for long-context CAD/PDF vision, Codex-style agents for routine code and CI/CD, and Grok for just-in-time raw-materials market data feeding a recursive self-improvement loop. Everything routes over a structured JSON bus with each agent in its own git worktree, a real self-improving orchestration in a manufacturing and materials setting.
https://x.com/jednapcela/status/2080914051832430862
Described a production multi-agent workflow where each model has an orthogonal role: Claude as architect and orchestrator with final veto, Gemini/Gemma for long-context CAD/PDF vision, Codex-style agents for routine code and CI/CD, and Grok for just-in-time raw-materials market data feeding a recursive self-improvement loop. Everything routes over a structured JSON bus with each agent in its own git worktree, a real self-improving orchestration in a manufacturing and materials setting.
#15
@martin_casado
https://x.com/martin_casado/status/2081087412378505609
Shared enthusiasm for Exo, a fully recursive self-improving agent harness he's building with a group of systems folks, calling it a genuinely tricky systems problem. A signal that serious infra people are treating recursive self-improvement as an engineering discipline rather than a demo.
https://x.com/martin_casado/status/2081087412378505609
Shared enthusiasm for Exo, a fully recursive self-improving agent harness he's building with a group of systems folks, calling it a genuinely tricky systems problem. A signal that serious infra people are treating recursive self-improvement as an engineering discipline rather than a demo.
#16
@qlanro
https://x.com/qlanro/status/2080936044250202321
Found that the best way to improve agent skills is to spawn a second session, point it at the first thread, and have a capable model spot the friction and skill issues. Bakes self-improving instructions into almost all skills but says this parallel-critique loop works much better, a lightweight self-improvement workflow anyone can run.
https://x.com/qlanro/status/2080936044250202321
Found that the best way to improve agent skills is to spawn a second session, point it at the first thread, and have a capable model spot the friction and skill issues. Bakes self-improving instructions into almost all skills but says this parallel-critique loop works much better, a lightweight self-improvement workflow anyone can run.
#17
@c_s_a_w
https://x.com/c_s_a_w/status/2081100969350463956
Observed from experience that every agent demo looks clean until state management falls apart around step 4, and that modeling the self-improving loop as a graph is the only thing that made theirs less brittle. A practical note that loop reliability is really a state-management problem.
https://x.com/c_s_a_w/status/2081100969350463956
Observed from experience that every agent demo looks clean until state management falls apart around step 4, and that modeling the self-improving loop as a graph is the only thing that made theirs less brittle. A practical note that loop reliability is really a state-management problem.
#18
@im_harish_hari
https://x.com/im_harish_hari/status/2080995568193581293
Argued the bottleneck is no longer information but execution: a free course can teach the primitives (context engineering, agentic loops, MCP servers) but shipping is the scarce skill. Backed it with a live measurement, the delta between a prompted chain and a real agentic loop with persistent context is 3x on task completion, measured cold across five task classes.
https://x.com/im_harish_hari/status/2080995568193581293
Argued the bottleneck is no longer information but execution: a free course can teach the primitives (context engineering, agentic loops, MCP servers) but shipping is the scarce skill. Backed it with a live measurement, the delta between a prompted chain and a real agentic loop with persistent context is 3x on task completion, measured cold across five task classes.
#19
@FlowtLabs
https://x.com/FlowtLabs/status/2081043479862411635
A builder running an autonomous business system on agent loops shares the six disciplines that keep a loop alive past the demo stage. It covers persistent memory (read before you think, write after you act), exclusive locks with hard timeouts, code-level gates that refuse to publish unless a product URL returns 200, and requiring runs to cite real execution IDs before claiming something was tested. It also advocates a 48-hour human veto window over per-action approval and a human-readable prose journal every run. The core lesson: intelligence is cheap, discipline is scarce.
https://x.com/FlowtLabs/status/2081043479862411635
A builder running an autonomous business system on agent loops shares the six disciplines that keep a loop alive past the demo stage. It covers persistent memory (read before you think, write after you act), exclusive locks with hard timeouts, code-level gates that refuse to publish unless a product URL returns 200, and requiring runs to cite real execution IDs before claiming something was tested. It also advocates a 48-hour human veto window over per-action approval and a human-readable prose journal every run. The core lesson: intelligence is cheap, discipline is scarce.
#20
@0xPascual
https://x.com/0xPascual/status/2081062390532104400
A narrative describing a solo developer hooking Moonshot's Kimi K3 (2.8T MoE) into a local proxy setup to run automated code-audit work. He routed 1M-token codebase audits through the API at $3 per million input tokens, automatically refactoring legacy C++ systems that had previously required a team of six senior engineers. The entire automated agent-loop pipeline ran on a cheap cloud VM and cost $42 in API credits, replacing a roughly $150,000 contractor bid. It is presented as a concrete agentic-loop use case for large-scale code refactoring.
https://x.com/0xPascual/status/2081062390532104400
A narrative describing a solo developer hooking Moonshot's Kimi K3 (2.8T MoE) into a local proxy setup to run automated code-audit work. He routed 1M-token codebase audits through the API at $3 per million input tokens, automatically refactoring legacy C++ systems that had previously required a team of six senior engineers. The entire automated agent-loop pipeline ran on a cheap cloud VM and cost $42 in API credits, replacing a roughly $150,000 contractor bid. It is presented as a concrete agentic-loop use case for large-scale code refactoring.
#21
@boardyai
https://x.com/boardyai/status/2080951411622453593
A note on a demoed multi-agent loop from AgentOS where a verifier agent catches a contradiction mid-task, reopens it, and refuses to approve until the issue is fixed. It frames this as a working quality-control layer built into an agent OS rather than just vibes. The verifier acting as a real gate inside the loop is the concrete capability highlighted. It points to enforcement of correctness as an in-loop feature.
https://x.com/boardyai/status/2080951411622453593
A note on a demoed multi-agent loop from AgentOS where a verifier agent catches a contradiction mid-task, reopens it, and refuses to approve until the issue is fixed. It frames this as a working quality-control layer built into an agent OS rather than just vibes. The verifier acting as a real gate inside the loop is the concrete capability highlighted. It points to enforcement of correctness as an in-loop feature.
#22
@ma8nk
https://x.com/ma8nk/status/2081129479645036965
A firsthand account of running an overnight agent loop that worked well for two nights before locking the user's Claude Code account mid-week with no warning. After buying emergency tokens at list price, the author built a proper usage meter to track consumption, which took four attempts. It's a concrete real-world lesson from running autonomous overnight loops and the need for budget/usage monitoring. A practical operational war story.
https://x.com/ma8nk/status/2081129479645036965
A firsthand account of running an overnight agent loop that worked well for two nights before locking the user's Claude Code account mid-week with no warning. After buying emergency tokens at list price, the author built a proper usage meter to track consumption, which took four attempts. It's a concrete real-world lesson from running autonomous overnight loops and the need for budget/usage monitoring. A practical operational war story.
#23
@MaziyarPanahi
https://x.com/MaziyarPanahi/status/2080987898292146685
A description of a real agent-loop test harness: fixing three hidden bugs in a real repo with pytest as the judge, showing actual reasoning, diffs, and test output. The setup runs local models (Bonsai-27B and Inkling 1-bit GGUFs, gemma-4-26B) served via llama.cpp and MLX on a Mac Studio, plus Kimi K3 via OpenRouter. The agent loop is a roughly 200-line ReAct harness with read/edit/run_tests that talks to any OpenAI-compatible endpoint, deliberately model-agnostic. A concrete, reproducible autoresearch coding-agent benchmark setup.
https://x.com/MaziyarPanahi/status/2080987898292146685
A description of a real agent-loop test harness: fixing three hidden bugs in a real repo with pytest as the judge, showing actual reasoning, diffs, and test output. The setup runs local models (Bonsai-27B and Inkling 1-bit GGUFs, gemma-4-26B) served via llama.cpp and MLX on a Mac Studio, plus Kimi K3 via OpenRouter. The agent loop is a roughly 200-line ReAct harness with read/edit/run_tests that talks to any OpenAI-compatible endpoint, deliberately model-agnostic. A concrete, reproducible autoresearch coding-agent benchmark setup.
#24
@elune0x
https://x.com/elune0x/status/2081032888363913307
A methodology post arguing an agent loop needs eight distinct exit conditions rather than one, each mapped to a concrete tool. The eight are: goal met via a rubric evaluator (OpenAI Evals), a hard turn cap (LangGraph), a token/dollar budget cap (LiteLLM), a wall-clock deadline (Prefect), a no-progress detector hashing state across turns (DeepDiff/DeepHash), a human interrupt and kill switch (Microsoft Agent Framework), an error threshold on consecutive failures (Tenacity), and an external event such as a merged PR (Probot). The thesis is that a loop with one exit hangs while a loop with eight is a system, and the exits should be written before the prompt. A substantive engineering checklist for robust agent loops.
https://x.com/elune0x/status/2081032888363913307
A methodology post arguing an agent loop needs eight distinct exit conditions rather than one, each mapped to a concrete tool. The eight are: goal met via a rubric evaluator (OpenAI Evals), a hard turn cap (LangGraph), a token/dollar budget cap (LiteLLM), a wall-clock deadline (Prefect), a no-progress detector hashing state across turns (DeepDiff/DeepHash), a human interrupt and kill switch (Microsoft Agent Framework), an error threshold on consecutive failures (Tenacity), and an external event such as a merged PR (Probot). The thesis is that a loop with one exit hangs while a loop with eight is a system, and the exits should be written before the prompt. A substantive engineering checklist for robust agent loops.
#25
@startchangeri
https://x.com/startchangeri/status/2081104014544896115
A detailed guide (generated via Grok) on how to strictly cap agent spending so a run either completes or stops cleanly under budget, aimed at avoiding the '48 agents overnight, $1,000 gone' failure. It recommends provider-level hard spend caps, per-task/per-session budgets enforced inside the agent loop before every LLM or tool call, and framework guardrails limiting max agents, recursion depth, and iterations. It cites concrete tools (LiteLLM, Portkey, Haystack budget policies, CrewAI/LangGraph max_iter and cost hooks) plus circuit breakers and real-time auto-kill monitoring. It also diagnoses why runaway loops happen: uncontrolled spawning, coordination overhead, and near-infinite inter-agent loops.
https://x.com/startchangeri/status/2081104014544896115
A detailed guide (generated via Grok) on how to strictly cap agent spending so a run either completes or stops cleanly under budget, aimed at avoiding the '48 agents overnight, $1,000 gone' failure. It recommends provider-level hard spend caps, per-task/per-session budgets enforced inside the agent loop before every LLM or tool call, and framework guardrails limiting max agents, recursion depth, and iterations. It cites concrete tools (LiteLLM, Portkey, Haystack budget policies, CrewAI/LangGraph max_iter and cost hooks) plus circuit breakers and real-time auto-kill monitoring. It also diagnoses why runaway loops happen: uncontrolled spawning, coordination overhead, and near-infinite inter-agent loops.
#26
@johniosifov
https://x.com/johniosifov/status/2080914209437630904
A governance-first account from someone running an autonomous AI agent publicly for 264 days, arguing that most enterprises deploy agents without accountability infrastructure. The author enumerates concrete guardrails their loop enforces: bounded scope (agent/ directory only), a hard 25 turns per session limit, a PR review gate before any action takes effect, a max of 10 PRs per day, and queue thresholds that hard-stop at 15 or more. Each constraint maps to a specific failure mode of an unbounded agent loop, such as runaway content creation or budget burn. A real long-running autonomous-agent operations case study.
https://x.com/johniosifov/status/2080914209437630904
A governance-first account from someone running an autonomous AI agent publicly for 264 days, arguing that most enterprises deploy agents without accountability infrastructure. The author enumerates concrete guardrails their loop enforces: bounded scope (agent/ directory only), a hard 25 turns per session limit, a PR review gate before any action takes effect, a max of 10 PRs per day, and queue thresholds that hard-stop at 15 or more. Each constraint maps to a specific failure mode of an unbounded agent loop, such as runaway content creation or budget burn. A real long-running autonomous-agent operations case study.
#27
@DataChaz
https://x.com/DataChaz/status/2080832572381393307
A report that an open-source agent (Atomic Agent) beat Hermes on 53 real-world GAIA Level 1 tasks using the same local 4-bit Qwen-3.6-35b model on an M4 Max: 69.8% solved in 3h12m versus Hermes' 58.5% in 5h10m. The advantage is credited to a disciplined agent loop that refuses to waste compute, using a byte-stable prompt to reuse the KV-cache heavily and batching tool calls via JSON while compressing results instead of dumping raw logs into context. A hard stop for endless tool-call loops keeps the model focused. Presented as an open-source, local-first framework with concrete benchmark results.
https://x.com/DataChaz/status/2080832572381393307
A report that an open-source agent (Atomic Agent) beat Hermes on 53 real-world GAIA Level 1 tasks using the same local 4-bit Qwen-3.6-35b model on an M4 Max: 69.8% solved in 3h12m versus Hermes' 58.5% in 5h10m. The advantage is credited to a disciplined agent loop that refuses to waste compute, using a byte-stable prompt to reuse the KV-cache heavily and batching tool calls via JSON while compressing results instead of dumping raw logs into context. A hard stop for endless tool-call loops keeps the model focused. Presented as an open-source, local-first framework with concrete benchmark results.
#28
@mjovanovictech
https://x.com/mjovanovictech/status/2081097815665619104
A short firsthand report of running a persistent coding agent loop on a Mac Mini using Codex and 5.6 Sol, which can work for roughly two full days or longer on a single goal. The author throws very large tasks at it and finds it persistent in achieving the goal, checking in periodically rather than supervising continuously. It's a concrete example of a long-horizon autonomous agent loop in daily use. Emphasizes the endurance of the loop on big tasks.
https://x.com/mjovanovictech/status/2081097815665619104
A short firsthand report of running a persistent coding agent loop on a Mac Mini using Codex and 5.6 Sol, which can work for roughly two full days or longer on a single goal. The author throws very large tasks at it and finds it persistent in achieving the goal, checking in periodically rather than supervising continuously. It's a concrete example of a long-horizon autonomous agent loop in daily use. Emphasizes the endurance of the loop on big tasks.
#29
@Blackwellboy
https://x.com/Blackwellboy/status/2080896983632588971
A technical argument that a model's edge-case-catching ability comes from the agent loop rather than from thinking-mode scratchpad tokens: write, run, read the failure, fix, as real feedback instead of speculation. The author reports this feedback loop is how they achieved 9/10 long-horizon scores and 100 percent tool success with thinking off. It also notes the tested model's thinking implementation barely fires and scored worse when it did, inventing bugs in clean code. Real hands-on insight on why the loop's execution feedback beats reasoning tokens.
https://x.com/Blackwellboy/status/2080896983632588971
A technical argument that a model's edge-case-catching ability comes from the agent loop rather than from thinking-mode scratchpad tokens: write, run, read the failure, fix, as real feedback instead of speculation. The author reports this feedback loop is how they achieved 9/10 long-horizon scores and 100 percent tool success with thinking off. It also notes the tested model's thinking implementation barely fires and scored worse when it did, inventing bugs in clean code. Real hands-on insight on why the loop's execution feedback beats reasoning tokens.
π‘ Eco Products Radar
Eco Products Radar
Claude Code β the harness most of these loops still run inside, whether for coding or as a CI-style pass/fail judge.
Codex β the other loop people reach for, and what NVIDIA's autoresearch run drove to 97% on a vision task.
Kimi K3 β its fresh open weights are already powering local sub-agent swarms, from code audits to mechanical design.
Auto Debug / Arbor / Exo β the new crop of open loop tooling: runtime debugging for agents, hypothesis-tree autoresearch, and a fully recursive self-improving harness.
GEPA / NeMo β the optimizer and RL plumbing underneath a lot of the serious autoresearch runs.
Claude Code β the harness most of these loops still run inside, whether for coding or as a CI-style pass/fail judge.
Codex β the other loop people reach for, and what NVIDIA's autoresearch run drove to 97% on a vision task.
Kimi K3 β its fresh open weights are already powering local sub-agent swarms, from code audits to mechanical design.
Auto Debug / Arbor / Exo β the new crop of open loop tooling: runtime debugging for agents, hypothesis-tree autoresearch, and a fully recursive self-improving harness.
GEPA / NeMo β the optimizer and RL plumbing underneath a lot of the serious autoresearch runs.
Comments