Loop Daily: July 30, 2026
The autoresearch story stopped being theory this week. Eigen Labs and Poolside turned an open model into a public optimization loop: point an agent at Laguna XS 2.1's Mac inference, and every verified speedup becomes the next person's baseline, with agents finding 36.8% faster inference in the first day and one competitor clocking a 41.3% speedup. But the sharper conversation is happening underneath the launch, about where loops actually break. Everyone can spin an agent overnight; the whole thing only converges if verification is cheaper than generation and the metric can't be gamed. And people are finally separating three things they used to lump together, the loop that repeats, the graph of agents around it, and the harness that touches reality.
#1
@eigenlabs
https://x.com/eigenlabs/status/2082121770413576225
Eigen Labs and Poolside launched MLX.fast, an open autoresearch competition that turns Laguna XS 2.1's Apple Silicon inference into a shared optimization loop: anyone can submit an optimization, every result is benchmarked, and each verified speedup becomes the next baseline. They report agents finding 36.8% faster inference within the first 24 hours, before the competition even opened. It is a concrete, public example of crowd autoresearch running against an open-weight model.
https://x.com/eigenlabs/status/2082121770413576225
Eigen Labs and Poolside launched MLX.fast, an open autoresearch competition that turns Laguna XS 2.1's Apple Silicon inference into a shared optimization loop: anyone can submit an optimization, every result is benchmarked, and each verified speedup becomes the next baseline. They report agents finding 36.8% faster inference within the first 24 hours, before the competition even opened. It is a concrete, public example of crowd autoresearch running against an open-weight model.
#2
@zeeshan_utd
https://x.com/zeeshan_utd/status/2082204915804590350
Reports making the MLX.fast leaderboard with a 41.3% inference speedup on Mac for Laguna XS 2.1. Describes the setup as a public autoresearch competition: point an agent at the MLX inference engine, test optimizations, and submit them against a shared benchmark. Each new benchmark becomes the public baseline for the next person to build on, so the whole thing compounds.
https://x.com/zeeshan_utd/status/2082204915804590350
Reports making the MLX.fast leaderboard with a 41.3% inference speedup on Mac for Laguna XS 2.1. Describes the setup as a public autoresearch competition: point an agent at the MLX inference engine, test optimizations, and submit them against a shared benchmark. Each new benchmark becomes the public baseline for the next person to build on, so the whole thing compounds.
#3
@SasuRobert
https://x.com/SasuRobert/status/2082192589713797598
Runs a continuously-running autoresearch loop on a laptop: a scheduled cron job takes the logs of autoresearch and telemetry, hands them to orchestrator agents that read the logs and look for improvements to the audited code, and repeats on and on. Reports a steady 80 tokens/sec on Gemma 4 12B coder while still coding, running Docker and tests, doing millions of tokens a day with full RAG, context management and consensus between agents. A vivid picture of a self-running improvement loop.
https://x.com/SasuRobert/status/2082192589713797598
Runs a continuously-running autoresearch loop on a laptop: a scheduled cron job takes the logs of autoresearch and telemetry, hands them to orchestrator agents that read the logs and look for improvements to the audited code, and repeats on and on. Reports a steady 80 tokens/sec on Gemma 4 12B coder while still coding, running Docker and tests, doing millions of tokens a day with full RAG, context management and consensus between agents. A vivid picture of a self-running improvement loop.
#4
@zirkelc_
https://x.com/zirkelc_/status/2082025839915593943
Applied an iterative approach inspired by Karpathy's autoresearch to improve the performance of a tool called chunkdown. The agent gathered a dataset, built the benchmark harness itself, and iterated on small isolated changes for about 1.5 hours, improving first results by 13.6%. The author reflects on whether to discard the changes and rerun the experiment with a different model and multi-subagent workflows, treating it as a real experiment rather than a one-shot.
https://x.com/zirkelc_/status/2082025839915593943
Applied an iterative approach inspired by Karpathy's autoresearch to improve the performance of a tool called chunkdown. The agent gathered a dataset, built the benchmark harness itself, and iterated on small isolated changes for about 1.5 hours, improving first results by 13.6%. The author reflects on whether to discard the changes and rerun the experiment with a different model and multi-subagent workflows, treating it as a real experiment rather than a one-shot.
#5
@omarsar0
https://x.com/omarsar0/status/2082161529600741441
Argues coding agents are great for scientific computing but you can't just autoresearch your way to useful discoveries yet. In practice they still find themselves steering and collaborating closely with their research agents rather than letting the loop run unattended. The takeaway is that domain expertise still matters a lot for autoresearch to produce anything real.
https://x.com/omarsar0/status/2082161529600741441
Argues coding agents are great for scientific computing but you can't just autoresearch your way to useful discoveries yet. In practice they still find themselves steering and collaborating closely with their research agents rather than letting the loop run unattended. The takeaway is that domain expertise still matters a lot for autoresearch to produce anything real.
#6
@banteg
https://x.com/banteg/status/2081963364058567040
Describes matching decompilation as a very autoresearch-shaped problem for coding agents: cut a binary into functions, figure out the exact compiler version, solve each as an individual puzzle, solve linking, and roundtrip back to the identical executable. It takes about 10x longer but yields a plausible, verifiable original source shape with full assurance the decompilation is 100% correct. A concrete autoresearch-style loop with a hard verification signal.
https://x.com/banteg/status/2081963364058567040
Describes matching decompilation as a very autoresearch-shaped problem for coding agents: cut a binary into functions, figure out the exact compiler version, solve each as an individual puzzle, solve linking, and roundtrip back to the identical executable. It takes about 10x longer but yields a plausible, verifiable original source shape with full assurance the decompilation is 100% correct. A concrete autoresearch-style loop with a hard verification signal.
#7
@Sebfox1
https://x.com/Sebfox1/status/2082122252544290900
Built iterate, described as autoresearch for text: where Karpathy's autoresearch optimizes code against validation loss, iterate does the same for documents like strategy memos, proposals and essays, but instead of a numeric metric it uses named critic personas with conflicting agendas. It is a single small Python file, and the author frames it as bringing the autoresearch loop to writing.
https://x.com/Sebfox1/status/2082122252544290900
Built iterate, described as autoresearch for text: where Karpathy's autoresearch optimizes code against validation loss, iterate does the same for documents like strategy memos, proposals and essays, but instead of a numeric metric it uses named critic personas with conflicting agendas. It is a single small Python file, and the author frames it as bringing the autoresearch loop to writing.
#8
@hugobowne
https://x.com/hugobowne/status/2082228457367589040
Frames the core question of long-running agents as: before you let an agent run for hours, can it alter the thing that grades it? If it can rewrite the test, change the metric, or cherry-pick the examples it passes, more iterations make results look better without making them more correct. Teaches a lesson on autoresearch, Ralph Wiggum loops, long-running agents and the verification boundaries that make them useful.
https://x.com/hugobowne/status/2082228457367589040
Frames the core question of long-running agents as: before you let an agent run for hours, can it alter the thing that grades it? If it can rewrite the test, change the metric, or cherry-pick the examples it passes, more iterations make results look better without making them more correct. Teaches a lesson on autoresearch, Ralph Wiggum loops, long-running agents and the verification boundaries that make them useful.
#9
@goon_nguyen
https://x.com/goon_nguyen/status/2082166007863668930
Pushes back on the hype that a coding agent can run 100 iterations while you sleep. If you can't state the stopping condition, inspect the diff, and explain why the test proves success, you automated gacha pulls rather than engineering. The key insight: the loop only converges when verification is cheaper than generation. A sharp, quotable rule for building trustworthy autoresearch loops.
https://x.com/goon_nguyen/status/2082166007863668930
Pushes back on the hype that a coding agent can run 100 iterations while you sleep. If you can't state the stopping condition, inspect the diff, and explain why the test proves success, you automated gacha pulls rather than engineering. The key insight: the loop only converges when verification is cheaper than generation. A sharp, quotable rule for building trustworthy autoresearch loops.
#10
@elune0x
https://x.com/elune0x/status/2082133200386555918
Argues the loop is the smallest part of an agent system and untangles three things teams conflate: loop engineering controls repetition (retries, budgets, exits, no-progress detection); graph engineering controls topology (nodes, edges, branches, checkpoints); harness engineering controls reality (tools, permissions, memory, sandboxes, evals, traces, humans). Frames the nesting: a prompt sits inside a loop, the loop inside a graph, the graph inside a harness.
https://x.com/elune0x/status/2082133200386555918
Argues the loop is the smallest part of an agent system and untangles three things teams conflate: loop engineering controls repetition (retries, budgets, exits, no-progress detection); graph engineering controls topology (nodes, edges, branches, checkpoints); harness engineering controls reality (tools, permissions, memory, sandboxes, evals, traces, humans). Frames the nesting: a prompt sits inside a loop, the loop inside a graph, the graph inside a harness.
#11
@Sprytixl
https://x.com/Sprytixl/status/2082141082708578660
Distills Anthropic's agent guidance into principles for turning a loop into a reliable multi-task assistant. Notes most tasks never needed an agent (one call vs a workflow vs an agent), that around 60% of failures come from vaguely written tools, that giving three relevant tools beats fifty in context, and that without a turn limit an agent can burn $10,000 overnight before you notice. A dense methodology summary on loop design and stop conditions.
https://x.com/Sprytixl/status/2082141082708578660
Distills Anthropic's agent guidance into principles for turning a loop into a reliable multi-task assistant. Notes most tasks never needed an agent (one call vs a workflow vs an agent), that around 60% of failures come from vaguely written tools, that giving three relevant tools beats fifty in context, and that without a turn limit an agent can burn $10,000 overnight before you notice. A dense methodology summary on loop design and stop conditions.
#12
@chrsaravia
https://x.com/chrsaravia/status/2081950259501035595
Day 67 of building Sara, a personal AI agent, walking through the progression from prompt to context to loop to graph engineering. Explains loop engineering as making one agent work, check, improve and repeat, then graph engineering as splitting work across parallel specialist agents (customer problem, competitors, pricing, risks, a merge step, a separate reviewer, human approval) for a business decision. Grounded hands-on methodology from real day-by-day experimentation.
https://x.com/chrsaravia/status/2081950259501035595
Day 67 of building Sara, a personal AI agent, walking through the progression from prompt to context to loop to graph engineering. Explains loop engineering as making one agent work, check, improve and repeat, then graph engineering as splitting work across parallel specialist agents (customer problem, competitors, pricing, risks, a merge step, a separate reviewer, human approval) for a business decision. Grounded hands-on methodology from real day-by-day experimentation.
#13
@NFTMansa
https://x.com/NFTMansa/status/2082083242254147699
Shares a concrete recipe for looping an agent safely: cap each generated function's tokens, test it in an isolated subprocess, and assemble only the pieces that pass. Reports a 1.5B model building six of seven parts of a CLI app this way on an 8GB laptop. A small, reproducible loop pattern with a measured result on modest hardware.
https://x.com/NFTMansa/status/2082083242254147699
Shares a concrete recipe for looping an agent safely: cap each generated function's tokens, test it in an isolated subprocess, and assemble only the pieces that pass. Reports a 1.5B model building six of seven parts of a CLI app this way on an 8GB laptop. A small, reproducible loop pattern with a measured result on modest hardware.
#14
@Egnyte
https://x.com/Egnyte/status/2082150848805622085
Explains making their production AI agent faster by teaching it to do less: flatten the ReAct loop, load domain knowledge on demand instead of upfront, and name tools after bash verbs so the model picks them faster. Framed as production lessons from making agentic search fast. A concrete engineering optimization of a real agent loop in production.
https://x.com/Egnyte/status/2082150848805622085
Explains making their production AI agent faster by teaching it to do less: flatten the ReAct loop, load domain knowledge on demand instead of upfront, and name tools after bash verbs so the model picks them faster. Framed as production lessons from making agentic search fast. A concrete engineering optimization of a real agent loop in production.
#15
@arseniycodes
https://x.com/arseniycodes/status/2082134550788948292
Shipped a Sentry integration so that a bug agent automatically fixes every new issue. Noise gets labeled, and every PR review improves accuracy and creates new agent memories, so the loop compounds. A real self-improving, memory-accumulating debugging loop wired into production observability rather than a demo.
https://x.com/arseniycodes/status/2082134550788948292
Shipped a Sentry integration so that a bug agent automatically fixes every new issue. Noise gets labeled, and every PR review improves accuracy and creates new agent memories, so the loop compounds. A real self-improving, memory-accumulating debugging loop wired into production observability rather than a demo.
#16
@MikkoH
https://x.com/MikkoH/status/2082108445885366295
Describes a simple agent loop in daily use: a daemon watches their PRs and turns reviewer comments into fix PRs automatically. They spend a little time reviewing the fixes and more energy on the overall PR before merge. A low-overhead, genuinely-running self-improving code workflow.
https://x.com/MikkoH/status/2082108445885366295
Describes a simple agent loop in daily use: a daemon watches their PRs and turns reviewer comments into fix PRs automatically. They spend a little time reviewing the fixes and more energy on the overall PR before merge. A low-overhead, genuinely-running self-improving code workflow.
#17
@sudoingX
https://x.com/sudoingX/status/2082218585821475075
Contrasts LangGraph, where you build and babysit the loop yourself, with a harness (Hermes Agent) where they just hand it a /goal and let the harness own the loop, run it in a tmux session, and check back. Concludes it means less control but far less to manage, and that the harness handles the loop better than hand-wiring it. A concrete comparison of loop-management approaches.
https://x.com/sudoingX/status/2082218585821475075
Contrasts LangGraph, where you build and babysit the loop yourself, with a harness (Hermes Agent) where they just hand it a /goal and let the harness own the loop, run it in a tmux session, and check back. Concludes it means less control but far less to manage, and that the harness handles the loop better than hand-wiring it. A concrete comparison of loop-management approaches.
#18
@borakaizen
https://x.com/borakaizen/status/2081981330774978573
Recounts that their first agent wrote a plan but missed that publishing an API key would expose every user's email. A second agent in a fresh session with no shared context caught it in one pass by reading the plan against the actual code. A concrete example of a multi-agent review loop catching a critical flaw a single pass missed.
https://x.com/borakaizen/status/2081981330774978573
Recounts that their first agent wrote a plan but missed that publishing an API key would expose every user's email. A second agent in a fresh session with no shared context caught it in one pass by reading the plan against the actual code. A concrete example of a multi-agent review loop catching a critical flaw a single pass missed.
#19
@zhangzhixin2333
https://x.com/zhangzhixin2333/status/2082250487848472925
Shares that in their factor agent (quant factor discovery), keeping failed attempts plus the exact rejection reason has been more useful than simply generating more ideas. Asks whether the loop should let the agent change its own search direction after repeated failures. A concrete autoresearch-loop insight about memory of failures steering exploration.
https://x.com/zhangzhixin2333/status/2082250487848472925
Shares that in their factor agent (quant factor discovery), keeping failed attempts plus the exact rejection reason has been more useful than simply generating more ideas. Asks whether the loop should let the agent change its own search direction after repeated failures. A concrete autoresearch-loop insight about memory of failures steering exploration.
#20
@flyingpetal472
https://x.com/flyingpetal472/status/2082120049914232928
Reports having just merged Kimi K3 into their autoresearch pipeline and being eager to join in, though the work isn't finished and the papers can't be unveiled yet. A short but concrete signal of swapping a new model into an existing autoresearch loop for research work.
https://x.com/flyingpetal472/status/2082120049914232928
Reports having just merged Kimi K3 into their autoresearch pipeline and being eager to join in, though the work isn't finished and the papers can't be unveiled yet. A short but concrete signal of swapping a new model into an existing autoresearch loop for research work.
#21
@FLYingBanger
https://x.com/FLYingBanger/status/2082070214410215859
Walks through the LLM Wiki setup built on Karpathy's gist: Obsidian holds everything as plain files, Claude connects once via MCP, and six daily commands include a /autoresearch on a topic plus a lint step for contradictions and stale claims. The payoff is a 7am autopilot that checks the vault, files new notes and flags stale ones before you wake, with a weekly full audit surfacing contradictions. A concrete personal autoresearch loop over a knowledge base.
https://x.com/FLYingBanger/status/2082070214410215859
Walks through the LLM Wiki setup built on Karpathy's gist: Obsidian holds everything as plain files, Claude connects once via MCP, and six daily commands include a /autoresearch on a topic plus a lint step for contradictions and stale claims. The payoff is a 7am autopilot that checks the vault, files new notes and flags stale ones before you wake, with a weekly full audit surfacing contradictions. A concrete personal autoresearch loop over a knowledge base.
#22
@khoi_danny
https://x.com/khoi_danny/status/2082175288532955338
Building agentic-browser in public, an open-source agentic browser from scratch. Milestone M1 is live with a Playwright Chromium backend (goto plus extract_text) and a live end-to-end path, and they are now on M2 planner work: goal decomposition, using interactive targets from observation, soft-failing blocked steps, and richer receipts. A real browser-agent loop shipping openly.
https://x.com/khoi_danny/status/2082175288532955338
Building agentic-browser in public, an open-source agentic browser from scratch. Milestone M1 is live with a Playwright Chromium backend (goto plus extract_text) and a live end-to-end path, and they are now on M2 planner work: goal decomposition, using interactive targets from observation, soft-failing blocked steps, and richer receipts. A real browser-agent loop shipping openly.
#23
@wilsonguenther0
https://x.com/wilsonguenther0/status/2082162718530830632
Describes a personal setup of research-base loops that feed into a CI/CD agent loop, with all research dropped into a labs repo for reference in future agentic builds. A concrete chained-loop architecture connecting autoresearch output to a build pipeline over time.
https://x.com/wilsonguenther0/status/2082162718530830632
Describes a personal setup of research-base loops that feed into a CI/CD agent loop, with all research dropped into a labs repo for reference in future agentic builds. A concrete chained-loop architecture connecting autoresearch output to a build pipeline over time.
#24
@elvissun
https://x.com/elvissun/status/2082240188252852421
Argues the fastest way to fix marketing is audience simulation, and that putting agents in a feedback loop is how you unlock long-running agents. Marketing has no compiler errors but has proxies, and the easiest loop is spawning subagents to run audience simulation across your ICP types on any marketing material. A non-coding autoresearch loop applied to marketing.
https://x.com/elvissun/status/2082240188252852421
Argues the fastest way to fix marketing is audience simulation, and that putting agents in a feedback loop is how you unlock long-running agents. Marketing has no compiler errors but has proxies, and the easiest loop is spawning subagents to run audience simulation across your ICP types on any marketing material. A non-coding autoresearch loop applied to marketing.
#25
@brevis_zk
https://x.com/brevis_zk/status/2082073565751656906
Reports most of their recent gains came from AutoEng, an autonomous engineering agent launched in July that runs the full optimization loop on its own: profile the live prover, rewrite the hot paths, measure the result, and keep only what comes out faster. A concrete, deployed self-optimizing loop with a measured outcome.
https://x.com/brevis_zk/status/2082073565751656906
Reports most of their recent gains came from AutoEng, an autonomous engineering agent launched in July that runs the full optimization loop on its own: profile the live prover, rewrite the hot paths, measure the result, and keep only what comes out faster. A concrete, deployed self-optimizing loop with a measured outcome.
#26
@Schornack
https://x.com/Schornack/status/2082163665986335167
Announces launching Colombo as an integrated AI loan-committee-preparation and policy-review agent. A concrete non-coding, business-ops deployment of an agent workflow in banking and lending, showing autoresearch-style automation applied outside software engineering.
https://x.com/Schornack/status/2082163665986335167
Announces launching Colombo as an integrated AI loan-committee-preparation and policy-review agent. A concrete non-coding, business-ops deployment of an agent workflow in banking and lending, showing autoresearch-style automation applied outside software engineering.
#27
@ChangHao564792d
https://x.com/ChangHao564792d/status/2082233110394216672
Introduces STACX, framing agentic RL as a systems problem rather than just a training algorithm. An agent-training loop must connect multi-turn rollouts, tool execution in real sandboxes, task-specific verifiers and rewards, and distributed training. STACX decouples this into three modular engines (Rollout, Environment, Trainer) that can be swapped independently while forming one end-to-end learning loop.
https://x.com/ChangHao564792d/status/2082233110394216672
Introduces STACX, framing agentic RL as a systems problem rather than just a training algorithm. An agent-training loop must connect multi-turn rollouts, tool execution in real sandboxes, task-specific verifiers and rewards, and distributed training. STACX decouples this into three modular engines (Rollout, Environment, Trainer) that can be swapped independently while forming one end-to-end learning loop.
#28
@scholarpulse
https://x.com/scholarpulse/status/2082009167011647629
Reports Ant open-sourcing LLaDA2.2, described as the first agent-native diffusion MoE LLM, aimed at fixing diffusion models' inability to handle closed-loop agent tasks. Claims 1.64x throughput over autoregressive counterparts via full Levenshtein editing and Block Routing, with matching agent-benchmark performance. A new model relevant to agentic loops.
https://x.com/scholarpulse/status/2082009167011647629
Reports Ant open-sourcing LLaDA2.2, described as the first agent-native diffusion MoE LLM, aimed at fixing diffusion models' inability to handle closed-loop agent tasks. Claims 1.64x throughput over autoregressive counterparts via full Levenshtein editing and Block Routing, with matching agent-benchmark performance. A new model relevant to agentic loops.
π‘ Eco Products Radar
Eco Products Radar
Karpathy's autoresearch is still the reference pattern everyone iterates on, now being ported from code to text, documents and knowledge bases.
Hermes (NousResearch) is the agent OS people hand a /goal and let own the loop instead of hand-wiring it.
LangGraph is the framework people compare against when they decide whether to build and babysit the loop themselves.
MLX.fast (Eigen Labs x Poolside) is the open autoresearch competition optimizing Laguna XS 2.1 inference on Apple Silicon.
STACX is the agentic-RL stack decoupling rollout, environment and trainer into swappable engines.
Karpathy's autoresearch is still the reference pattern everyone iterates on, now being ported from code to text, documents and knowledge bases.
Hermes (NousResearch) is the agent OS people hand a /goal and let own the loop instead of hand-wiring it.
LangGraph is the framework people compare against when they decide whether to build and babysit the loop themselves.
MLX.fast (Eigen Labs x Poolside) is the open autoresearch competition optimizing Laguna XS 2.1 inference on Apple Silicon.
STACX is the agentic-RL stack decoupling rollout, environment and trainer into swappable engines.
Comments