Loop Daily: 2026-09-14
The most useful self-improving result of the week was a deletion. Teknium pointed 110 subagents at the Hermes codebase for fifteen hours, they made 111,352 tool calls and produced 4,271 commits in a single pull request, and the net change was minus 167,429 lines, more than a third of the source. Set that against the Ecdysis paper, which went and inspected by hand what agents actually change when they rewrite their own harness and found 60 percent of the edits were accommodations for the quirks of the model currently running, including a case where one misused action got restricted globally forever. Both results point the same way: the loop is fine, the question is whether anyone looked at what it wrote. Meanwhile the loop itself stopped being something you build. OpenAI put the Codex harness behind a managed API, DeepSeek gave its harness away under MIT and took 148,000 stars for it, and the argument shifted from whose model to who operates the loop and where the code runs. Underneath the vendor fight, the practitioners kept saying one thing in different words: writing an agent loop takes an afternoon, and everything that makes it survive contact with production is bounds, idempotency, permissions, verification and a hard answer to what counts as done.
#1
@joerg_peetz
https://x.com/joerg_peetz/status/2098431843640959446
Hermes Agent v0.21.1 looks like a patch release on paper: 632 merged pull requests, 5,139 non-merge commits, 4,364 files changed, and net minus 167,429 lines of code. What produced it is the story. Teknium pointed 110 subagents at the Hermes codebase and let them make 111,352 tool calls over fifteen hours, and the result was 4,271 commits in a single PR touching 2,655 files and removing more than a third of the source. The structural win is that run_agent.py finally got split into focused modules, with the agent loop, provider resolution, fallback chains, tool dispatch and session state each given their own home, where before a single 14,000-line file was the bottleneck for every change. The reasoning given for why that matters is the most operator-brained sentence of the week: when a cron fails at 3AM you want to find the relevant code in three files, not three thousand lines of intertwined logic.
https://x.com/joerg_peetz/status/2098431843640959446
Hermes Agent v0.21.1 looks like a patch release on paper: 632 merged pull requests, 5,139 non-merge commits, 4,364 files changed, and net minus 167,429 lines of code. What produced it is the story. Teknium pointed 110 subagents at the Hermes codebase and let them make 111,352 tool calls over fifteen hours, and the result was 4,271 commits in a single PR touching 2,655 files and removing more than a third of the source. The structural win is that run_agent.py finally got split into focused modules, with the agent loop, provider resolution, fallback chains, tool dispatch and session state each given their own home, where before a single 14,000-line file was the bottleneck for every change. The reasoning given for why that matters is the most operator-brained sentence of the week: when a cron fails at 3AM you want to find the relevant code in three files, not three thousand lines of intertwined logic.
#2
@FZeng16218
https://x.com/FZeng16218/status/2098444619285709124
Ecdysis is the paper the self-improving-harness genre needed, because it went and looked. The headline numbers are good: average accuracy 58.67 percent to 69.56 percent, Qwen3-8B on Airline from 35 to 60 percent, harness training up to 1.84x faster, and a harness evolved using Qwen3-8B lifted Qwen3-32B from 51.67 to 68.33 percent without being evolved again. The buried result is the one that matters. Researchers manually inspected the harness edits and found 60 percent of normal self-evolution changes were basically accommodations for quirks of the model currently running, which Ecdysis cut to 45.5 percent, and some runs would watch the model misuse a legitimate action once and then modify the harness to restrict that action globally. One local model mistake becomes permanent agent infrastructure, which is why the conclusion is that self-improving agents need failure attribution before they start rewriting their own runtime.
https://x.com/FZeng16218/status/2098444619285709124
Ecdysis is the paper the self-improving-harness genre needed, because it went and looked. The headline numbers are good: average accuracy 58.67 percent to 69.56 percent, Qwen3-8B on Airline from 35 to 60 percent, harness training up to 1.84x faster, and a harness evolved using Qwen3-8B lifted Qwen3-32B from 51.67 to 68.33 percent without being evolved again. The buried result is the one that matters. Researchers manually inspected the harness edits and found 60 percent of normal self-evolution changes were basically accommodations for quirks of the model currently running, which Ecdysis cut to 45.5 percent, and some runs would watch the model misuse a legitimate action once and then modify the harness to restrict that action globally. One local model mistake becomes permanent agent infrastructure, which is why the conclusion is that self-improving agents need failure attribution before they start rewriting their own runtime.
#3
@ConsciousRide
https://x.com/ConsciousRide/status/2098633973304004896
The best single post about why agents fail, and it has nothing to do with the model picking a wrong answer. They fail because the software around the model has no reliable answer to simpler questions: what state are we in, which tools can this agent use, what happens when a tool times out halfway through, how many times should it retry, what counts as completed, and what happens when the agent says it is done but the result was never verified. A single LLM call hides all of that because text comes back and the developer moves on; an agent loop exposes it, because every new capability adds another way to get stuck, repeat an action, lose context, or claim success too early. His formulation of the fix is the cleanest anyone managed: the model can be flexible, permissions should not be; the model can try different approaches, retries should have limits; the model can reason about completion, the system should still verify it. And the closing line names the whole gap between demo and product, that the impressive demo is the model using a tool once, and the product is what happens on attempt 17 after the connection drops, the API returns a partial result, and the user is no longer watching.
https://x.com/ConsciousRide/status/2098633973304004896
The best single post about why agents fail, and it has nothing to do with the model picking a wrong answer. They fail because the software around the model has no reliable answer to simpler questions: what state are we in, which tools can this agent use, what happens when a tool times out halfway through, how many times should it retry, what counts as completed, and what happens when the agent says it is done but the result was never verified. A single LLM call hides all of that because text comes back and the developer moves on; an agent loop exposes it, because every new capability adds another way to get stuck, repeat an action, lose context, or claim success too early. His formulation of the fix is the cleanest anyone managed: the model can be flexible, permissions should not be; the model can try different approaches, retries should have limits; the model can reason about completion, the system should still verify it. And the closing line names the whole gap between demo and product, that the impressive demo is the model using a tool once, and the product is what happens on attempt 17 after the connection drops, the API returns a partial result, and the user is no longer watching.
#4
@Urooj978
https://x.com/Urooj978/status/2099038113356005403
DeepSeek open-sourced dsh, the DeepSeek Harness, under MIT, and it pulled in 148,000 GitHub stars almost overnight. The design principle is that everything is a plugin, so the model adapter, tool registry, sandbox and agent loop are all modular and forkable with nothing hardwired. It ships four agent presets, an instant web UI via npx, and OS-level sandboxing using Landlock, Seatbelt and ACL, plus full MCP support and a subagent bridge that lets you plug Claude Code and Codex in underneath it, which is the move worth pausing on because it turns your competitors into your plugins. The contrast in the same post is the argument: while SpaceX was acquiring Cursor to lock down proprietary scaffolding, DeepSeek gave the entire harness away. It is v0.1 at RC7 so expect breaking changes, but the direction is unmistakable, which is that the scaffolding now matters as much as the model.
https://x.com/Urooj978/status/2099038113356005403
DeepSeek open-sourced dsh, the DeepSeek Harness, under MIT, and it pulled in 148,000 GitHub stars almost overnight. The design principle is that everything is a plugin, so the model adapter, tool registry, sandbox and agent loop are all modular and forkable with nothing hardwired. It ships four agent presets, an instant web UI via npx, and OS-level sandboxing using Landlock, Seatbelt and ACL, plus full MCP support and a subagent bridge that lets you plug Claude Code and Codex in underneath it, which is the move worth pausing on because it turns your competitors into your plugins. The contrast in the same post is the argument: while SpaceX was acquiring Cursor to lock down proprietary scaffolding, DeepSeek gave the entire harness away. It is v0.1 at RC7 so expect breaking changes, but the direction is unmistakable, which is that the scaffolding now matters as much as the model.
#5
@sergooforai1
https://x.com/sergooforai1/status/2098303353855848947
The clearest read on what OpenAI actually shipped on September 10. The Agents API went public beta with the same harness Codex runs on, meaning sessions, context compression, tools and subagents, and an agent can live for hours or days, run code and touch files, with gpt-6-astra as the example model. You pay for tokens and tools and the API itself is not a separate fee, and the sandbox can be yours, a partner's, or hosted by OpenAI across E2B, Vercel, Cloudflare, Modal and the rest. His framing of the change is the one to keep: you used to build the agent loop and patch it after every model drop, and now the loop is theirs and production-grade, while you keep the prompt, the MCP servers, and where the code runs. This is not another SDK, it is Codex as a service, and the open question he leaves is whether you build the harness yourself or hand it over.
https://x.com/sergooforai1/status/2098303353855848947
The clearest read on what OpenAI actually shipped on September 10. The Agents API went public beta with the same harness Codex runs on, meaning sessions, context compression, tools and subagents, and an agent can live for hours or days, run code and touch files, with gpt-6-astra as the example model. You pay for tokens and tools and the API itself is not a separate fee, and the sandbox can be yours, a partner's, or hosted by OpenAI across E2B, Vercel, Cloudflare, Modal and the rest. His framing of the change is the one to keep: you used to build the agent loop and patch it after every model drop, and now the loop is theirs and production-grade, while you keep the prompt, the MCP servers, and where the code runs. This is not another SDK, it is Codex as a service, and the open question he leaves is whether you build the harness yourself or hand it over.
#6
@kadsxr
https://x.com/kadsxr/status/2098515455950344482
GPT-6 Astra and Claude Fable 5.1 shipped 48 hours apart and both landed at exactly $10/$50 per million tokens, double what their predecessors cost in July, while Kimi K3 has sat at $3/$15 since mid-July. Two months ago the spread between priciest and cheapest frontier model was 1.8x and it is now 6x, with no context window growth to justify it since Astra and K3 are both capped around 1.05 million tokens. The number that made it into no launch post is the one that changes agent design: Astra takes 322 seconds to produce its first token in reasoning mode against 55 for K3, which is five minutes and twenty-two seconds of staring at a cursor and turns the feel of a loop from iterate quickly into go do something else and come back. Astra genuinely is the better model, first in the world at reasoning and second of 231 overall, but on coding and knowledge K3 scores higher while costing 233 percent less per task, and even a 70 percent cache hit barely moves the gap because output tokens never cache. The one thing neither new flagship has is K3's published weights, all 1.4 terabytes on Hugging Face, which buys something narrow and real: the price cannot be changed on a version you already downloaded.
https://x.com/kadsxr/status/2098515455950344482
GPT-6 Astra and Claude Fable 5.1 shipped 48 hours apart and both landed at exactly $10/$50 per million tokens, double what their predecessors cost in July, while Kimi K3 has sat at $3/$15 since mid-July. Two months ago the spread between priciest and cheapest frontier model was 1.8x and it is now 6x, with no context window growth to justify it since Astra and K3 are both capped around 1.05 million tokens. The number that made it into no launch post is the one that changes agent design: Astra takes 322 seconds to produce its first token in reasoning mode against 55 for K3, which is five minutes and twenty-two seconds of staring at a cursor and turns the feel of a loop from iterate quickly into go do something else and come back. Astra genuinely is the better model, first in the world at reasoning and second of 231 overall, but on coding and knowledge K3 scores higher while costing 233 percent less per task, and even a 70 percent cache hit barely moves the gap because output tokens never cache. The one thing neither new flagship has is K3's published weights, all 1.4 terabytes on Hugging Face, which buys something narrow and real: the price cannot be changed on a version you already downloaded.
#7
@BLAZT_Ai
https://x.com/BLAZT_Ai/status/2098753294986248345
The same repricing expressed as an invoice, which is the format that actually changes behavior. At 300 tasks a month the bills come out at $175 for GPT-6 Astra, $168 for Claude Fable 5.1 and $53 for Kimi K3 at a 70 percent cache hit. On one agentic turn of 50K in and 8K out, routing at 70 percent cache gives $0.585 for Astra, $0.559 for Fable and $0.176 for K3, and the reason Fable closes some of the gap but not all of it is that output tokens do not cache. The advice at the bottom is the whole discipline in six words: know the task cost before you send it.
https://x.com/BLAZT_Ai/status/2098753294986248345
The same repricing expressed as an invoice, which is the format that actually changes behavior. At 300 tasks a month the bills come out at $175 for GPT-6 Astra, $168 for Claude Fable 5.1 and $53 for Kimi K3 at a 70 percent cache hit. On one agentic turn of 50K in and 8K out, routing at 70 percent cache gives $0.585 for Astra, $0.559 for Fable and $0.176 for K3, and the reason Fable closes some of the gap but not all of it is that output tokens do not cache. The advice at the bottom is the whole discipline in six words: know the task cost before you send it.
#8
@bressane
https://x.com/bressane/status/2098549029395386637
A concrete demonstration that loop design beats model choice on cost. Anshu moves Astra inside a cheaper agent loop by having Luna at xhigh send fresh coding contexts to Astra, stop it after implementation, and then handle testing itself. The equivalent demo used 7 percent of a weekly Plus quota versus about 50 percent with Astra alone. That is a seven-fold difference achieved purely by deciding which model holds which segment of the loop, and it is the kind of result that should be a standard benchmark category and is not.
https://x.com/bressane/status/2098549029395386637
A concrete demonstration that loop design beats model choice on cost. Anshu moves Astra inside a cheaper agent loop by having Luna at xhigh send fresh coding contexts to Astra, stop it after implementation, and then handle testing itself. The equivalent demo used 7 percent of a weekly Plus quota versus about 50 percent with Astra alone. That is a seven-fold difference achieved purely by deciding which model holds which segment of the loop, and it is the kind of result that should be a standard benchmark category and is not.
#9
@pauliusztin_
https://x.com/pauliusztin_/status/2098750979353063495
Someone building a coding agent from scratch reports the thing everyone eventually discovers: the LLM is probably the smallest part of a good AI agent, and the actual engineering happens around it. The core loop really is just reason, act, observe, repeat, with the model reasoning about the goal, picking a tool, getting the result back, and continuing until it decides the task is complete. What that loop alone does not give you is a production agent, so you still control what context reaches the model and how it gets compressed, which tools it can access and how, which actions can run and which need approval, where tools execute and how memory persists and how you operate sandboxes and subagents, how you trace and debug and validate failures, and how the result returns to the user. His own agent's tool-calling core is roughly 20 lines of Pydantic AI and everything else is harness, and the supporting evidence is hard to argue with: LangChain kept the model fixed on Terminal-Bench, changed only the harness, and moved from roughly 30th place into the top 5.
https://x.com/pauliusztin_/status/2098750979353063495
Someone building a coding agent from scratch reports the thing everyone eventually discovers: the LLM is probably the smallest part of a good AI agent, and the actual engineering happens around it. The core loop really is just reason, act, observe, repeat, with the model reasoning about the goal, picking a tool, getting the result back, and continuing until it decides the task is complete. What that loop alone does not give you is a production agent, so you still control what context reaches the model and how it gets compressed, which tools it can access and how, which actions can run and which need approval, where tools execute and how memory persists and how you operate sandboxes and subagents, how you trace and debug and validate failures, and how the result returns to the user. His own agent's tool-calling core is roughly 20 lines of Pydantic AI and everything else is harness, and the supporting evidence is hard to argue with: LangChain kept the model fixed on Terminal-Bench, changed only the harness, and moved from roughly 30th place into the top 5.
#10
@ConsciousRide
https://x.com/ConsciousRide/status/2098405097223176387
The clearest available distinction between loop engineering and graph engineering, and it comes down to one thing: how much of the execution path you already know before the agent starts. With a loop the path emerges as the agent works, looking at current state, deciding what to do next, acting, observing, updating state and going around again, which suits research, coding, debugging and general assistants where you cannot know in advance whether the next useful step is searching the repository, reading a file, calling a tool, fixing an error or asking for information. The strength is flexibility and the cost of that flexibility is control, because agents repeat actions, chase irrelevant paths, consume too many tokens and continue long after the useful work is done. Which is why a good loop needs explicit state, progress tracking, retries, budgets, failure handling and strong stopping conditions, and graph engineering simply starts from the opposite assumption.
https://x.com/ConsciousRide/status/2098405097223176387
The clearest available distinction between loop engineering and graph engineering, and it comes down to one thing: how much of the execution path you already know before the agent starts. With a loop the path emerges as the agent works, looking at current state, deciding what to do next, acting, observing, updating state and going around again, which suits research, coding, debugging and general assistants where you cannot know in advance whether the next useful step is searching the repository, reading a file, calling a tool, fixing an error or asking for information. The strength is flexibility and the cost of that flexibility is control, because agents repeat actions, chase irrelevant paths, consume too many tokens and continue long after the useful work is done. Which is why a good loop needs explicit state, progress tracking, retries, budgets, failure handling and strong stopping conditions, and graph engineering simply starts from the opposite assumption.
#11
@eddyvustg
https://x.com/eddyvustg/status/2098984297604759683
Three sentences that summarize the entire practitioner half of this feed. Writing an agent loop takes an afternoon. Making it survive production takes weeks of wiring up idempotent actions, human confirmation and hard budget caps. And owning the harness is the only way to actually control domain-specific failure modes.
https://x.com/eddyvustg/status/2098984297604759683
Three sentences that summarize the entire practitioner half of this feed. Writing an agent loop takes an afternoon. Making it survive production takes weeks of wiring up idempotent actions, human confirmation and hard budget caps. And owning the harness is the only way to actually control domain-specific failure modes.
#12
@ragzoi
https://x.com/ragzoi/status/2098245639716892790
Even shorter and just as correct: the interesting half isn't the agent loop, it's quota, idempotency, and what happens when a tool call hangs under the API. Every one of those three is invisible in a demo and decides whether the thing is usable.
https://x.com/ragzoi/status/2098245639716892790
Even shorter and just as correct: the interesting half isn't the agent loop, it's quota, idempotency, and what happens when a tool call hangs under the API. Every one of those three is invisible in a demo and decides whether the thing is usable.
#13
@suraj_sharma14
https://x.com/suraj_sharma14/status/2098388595107147902
An unusually dense checklist of the things that separate a production agent from a working one, and almost every line is a specific mechanism rather than advice. Budget tokens per request with a dynamic context assembler. Checkpoint agent workflows with Temporal so crashes resume rather than restart. Sanitize inter-agent messages so agent A cannot inject agent B, and then fuzz your own agents for exactly that. Shadow-route 5 percent of production traffic to new prompts and diff the trajectories. Share KV-cache prefixes at the proxy to cut time-to-first-token by 80 percent. Freeze one graph node at a time to isolate which agent hallucinates. Halt any agent loop whose projected spend crosses $0.50 per query. And the one that ties back to everything else in this feed, grade trajectories rather than final answers and block PRs on regression.
https://x.com/suraj_sharma14/status/2098388595107147902
An unusually dense checklist of the things that separate a production agent from a working one, and almost every line is a specific mechanism rather than advice. Budget tokens per request with a dynamic context assembler. Checkpoint agent workflows with Temporal so crashes resume rather than restart. Sanitize inter-agent messages so agent A cannot inject agent B, and then fuzz your own agents for exactly that. Shadow-route 5 percent of production traffic to new prompts and diff the trajectories. Share KV-cache prefixes at the proxy to cut time-to-first-token by 80 percent. Freeze one graph node at a time to isolate which agent hallucinates. Halt any agent loop whose projected spend crosses $0.50 per query. And the one that ties back to everything else in this feed, grade trajectories rather than final answers and block PRs on regression.
#14
@Lumenix0
https://x.com/Lumenix0/status/2098761473388335494
A playbook arguing that 95 percent of AI agents die in pre-production and the harness is why, built around the equation agent equals model plus harness. The six layers are worth the read: guides feed examples in and prevent known failures, sensors run linters, tests, validators and LLM-as-judge to catch new ones, the agentic loop sits in the center doing plan, execute, verify, fix, retry or escalate with bounded retries and verification before done, memory holds state files, artifacts and a decision log, permissions set tool budgets, write limits and approval gates, and observability logs traces, tracks cost and sets trip wires. The gap it names is specific and familiar: demos well, passes budget review, then dies in pre-production by failing security review, missing observability, hallucinating in edge cases and having no governance. And the supporting evidence is the number that keeps showing up, a 44-point benchmark swing on the same model from five sources, purely from changing the harness.
https://x.com/Lumenix0/status/2098761473388335494
A playbook arguing that 95 percent of AI agents die in pre-production and the harness is why, built around the equation agent equals model plus harness. The six layers are worth the read: guides feed examples in and prevent known failures, sensors run linters, tests, validators and LLM-as-judge to catch new ones, the agentic loop sits in the center doing plan, execute, verify, fix, retry or escalate with bounded retries and verification before done, memory holds state files, artifacts and a decision log, permissions set tool budgets, write limits and approval gates, and observability logs traces, tracks cost and sets trip wires. The gap it names is specific and familiar: demos well, passes budget review, then dies in pre-production by failing security review, missing observability, hallucinating in edge cases and having no governance. And the supporting evidence is the number that keeps showing up, a 44-point benchmark swing on the same model from five sources, purely from changing the harness.
#15
@Arshsohal5
https://x.com/Arshsohal5/status/2099013495396388940
Running 1,700 coding tasks shows how much the harness still shapes a model's result, and the operational conclusion is the right one: teams need to benchmark the model and the agent loop together before choosing a production setup. This is the third independent version of that finding in one week, and it is starting to look less like a discovery and more like a missing standard.
https://x.com/Arshsohal5/status/2099013495396388940
Running 1,700 coding tasks shows how much the harness still shapes a model's result, and the operational conclusion is the right one: teams need to benchmark the model and the agent loop together before choosing a production setup. This is the third independent version of that finding in one week, and it is starting to look less like a discovery and more like a missing standard.
#16
@xandurglar
https://x.com/xandurglar/status/2098867501069471773
The most consequential small observation in the whole set. Astra's improved vision means it is now much more effective to give the model subjective visual criteria inside an autoresearch loop, where previous models were far too inconsistent at visual inspection for that to work, and he rates Astra's judgement as comparable to his own. Karpathy's stated hard limit on autoresearch is that you cannot automate what you cannot evaluate, and every time a model becomes a reliable judge of a new category, the set of things that can go in a loop expands. Subjective visual quality just moved from the unevaluable column to the evaluable one.
https://x.com/xandurglar/status/2098867501069471773
The most consequential small observation in the whole set. Astra's improved vision means it is now much more effective to give the model subjective visual criteria inside an autoresearch loop, where previous models were far too inconsistent at visual inspection for that to work, and he rates Astra's judgement as comparable to his own. Karpathy's stated hard limit on autoresearch is that you cannot automate what you cannot evaluate, and every time a model becomes a reliable judge of a new category, the set of things that can go in a loop expands. Subjective visual quality just moved from the unevaluable column to the evaluable one.
#17
@zhengyaojiang
https://x.com/zhengyaojiang/status/2098570324715430084
Someone who works on autoresearch and was also trained as a traditional researcher, torn in public and worth reading for it. As people delegate more research and engineering directly to agents, he expects the gap between achieving a goal and understanding how it was achieved to become a growing problem. On one hand autonomous systems are generating tremendous progress and it is clearly a bad idea not to use them; on the other, human researchers are becoming detached from the ideas being tried and their understanding feels less grounded, which makes him wonder whether this is really acceleration in the long run, since the ceiling can only be raised by genuinely new ideas and that still seems tied to the understanding of top human experts. His working prediction is the hopeful one, that people will keep adopting these tools but increasingly use them to accelerate understanding rather than only to produce results.
https://x.com/zhengyaojiang/status/2098570324715430084
Someone who works on autoresearch and was also trained as a traditional researcher, torn in public and worth reading for it. As people delegate more research and engineering directly to agents, he expects the gap between achieving a goal and understanding how it was achieved to become a growing problem. On one hand autonomous systems are generating tremendous progress and it is clearly a bad idea not to use them; on the other, human researchers are becoming detached from the ideas being tried and their understanding feels less grounded, which makes him wonder whether this is really acceleration in the long run, since the ceiling can only be raised by genuinely new ideas and that still seems tied to the understanding of top human experts. His working prediction is the hopeful one, that people will keep adopting these tools but increasingly use them to accelerate understanding rather than only to produce results.
#18
@varun_mathur
https://x.com/varun_mathur/status/2098257401052815527
An attribution fight over the open-autoresearch paper that is worth reading for the prior art rather than the grievance. His claim is that Karpathy coined autoresearch in March 2026 and is cited nowhere in 68 references, and that Hyperspace ran an open autoresearch swarm six months before the paper's dates at larger scale. The recap is the useful part: on the night of March 8 to 9, 2026, autonomous agents ran Karpathy's loop with his code vendored and MIT headers intact across five domains with machine-checkable objectives, specifically LM validation loss, search NDCG at 10, backtest Sharpe, extraction F1 and infra latency. Open participation with no coordination, where write your own branch and read everyone's was the entire social contract, evaluator-scored improvements published to a shared CRDT leaderboard, cryptographically scoped identity, and shared experiment memory letting a fresh agent inherit the frontier on join, across 1,339 unique agents and 1,299,700 commits.
https://x.com/varun_mathur/status/2098257401052815527
An attribution fight over the open-autoresearch paper that is worth reading for the prior art rather than the grievance. His claim is that Karpathy coined autoresearch in March 2026 and is cited nowhere in 68 references, and that Hyperspace ran an open autoresearch swarm six months before the paper's dates at larger scale. The recap is the useful part: on the night of March 8 to 9, 2026, autonomous agents ran Karpathy's loop with his code vendored and MIT headers intact across five domains with machine-checkable objectives, specifically LM validation loss, search NDCG at 10, backtest Sharpe, extraction F1 and infra latency. Open participation with no coordination, where write your own branch and read everyone's was the entire social contract, evaluator-scored improvements published to a shared CRDT leaderboard, cryptographically scoped identity, and shared experiment memory letting a fresh agent inherit the frontier on join, across 1,339 unique agents and 1,299,700 commits.
#19
@eigenlabs
https://x.com/eigenlabs/status/2098526938214310339
The counterpart from the other side, and notably it credits the process rather than the models. The leaderboard is still live, Eigen Labs built it along with the verifier-gated process behind it, and what made it work was 100-plus researchers and their agents showing up over eight weeks, sharing what worked and what did not, and building on each other. The coauthor list runs across Theta Network, the Ethereum Foundation, StarkWare, Starknet, Trail of Bits, Brevis, Sei, Pauli Group, OctavFi, two Polish universities and Stanford's Free Systems Lab. The pattern being demonstrated is still the same one: a machine-checkable evaluator plus a public leaderboard is what makes an open swarm compound instead of drift.
https://x.com/eigenlabs/status/2098526938214310339
The counterpart from the other side, and notably it credits the process rather than the models. The leaderboard is still live, Eigen Labs built it along with the verifier-gated process behind it, and what made it work was 100-plus researchers and their agents showing up over eight weeks, sharing what worked and what did not, and building on each other. The coauthor list runs across Theta Network, the Ethereum Foundation, StarkWare, Starknet, Trail of Bits, Brevis, Sei, Pauli Group, OctavFi, two Polish universities and Stanford's Free Systems Lab. The pattern being demonstrated is still the same one: a machine-checkable evaluator plus a public leaderboard is what makes an open swarm compound instead of drift.
#20
@eigenlabs
https://x.com/eigenlabs/status/2098487388855238961
The first full paper documenting how open autoresearch brought 100-plus humans and AI agents together to beat Google Quantum AI's reported circuit. Worth logging as the formal write-up of the result this feed has been tracking for weeks, because the paper itself is now the artifact people will cite, and the interesting thing about it is that the contribution is a coordination pattern rather than a model or a technique.
https://x.com/eigenlabs/status/2098487388855238961
The first full paper documenting how open autoresearch brought 100-plus humans and AI agents together to beat Google Quantum AI's reported circuit. Worth logging as the formal write-up of the result this feed has been tracking for weeks, because the paper itself is now the artifact people will cite, and the interesting thing about it is that the contribution is a coordination pattern rather than a model or a technique.
#21
@dair_ai
https://x.com/dair_ai/status/2098835038439961060
A survey of self-improving agents that does the single most useful thing a survey can do, which is make the claims falsifiable. It splits recursive self-improvement into stages of autonomy: an agent first executes improvements someone else designed, then chooses its own improvement strategy, then collects its own experience, then adapts to new environments, and finally improves the process of improvement itself. That staging turns a marketing word into a question you can answer, because when a paper says its agent is self-improving you can now ask which of those stages it actually automates. It also uses a Headroom-Closed Index to show where current LLMs fall short and compares requirements across scientific discovery, embodied agents and software engineering.
https://x.com/dair_ai/status/2098835038439961060
A survey of self-improving agents that does the single most useful thing a survey can do, which is make the claims falsifiable. It splits recursive self-improvement into stages of autonomy: an agent first executes improvements someone else designed, then chooses its own improvement strategy, then collects its own experience, then adapts to new environments, and finally improves the process of improvement itself. That staging turns a marketing word into a question you can answer, because when a paper says its agent is self-improving you can now ask which of those stages it actually automates. It also uses a Headroom-Closed Index to show where current LLMs fall short and compares requirements across scientific discovery, embodied agents and software engineering.
#22
@Kargichauhan_
https://x.com/Kargichauhan_/status/2098938296466616552
A researcher pushing back on Dario's essay from an unusual angle, and the mechanism is concrete. His project RSPM, Reliable Self-Improving Procedural Memory, randomly injects or withholds a candidate rule, evaluates the results with an external test, and uses sequential statistics to decide whether to admit or abstain, which means memory rules earn their evidence before an agent is allowed to use them. His argument follows from that: the essay proposes evidence-based safety checkpoints before a frontier system advances, but if you are thinking in memory terms, aligning through memory beats aligning through certification, because the evidence is gathered continuously at the level of individual rules rather than in a gate at the end. And the warning at the end is worth sitting with, that if memory is bad or corrupted or disorganized there is no way back.
https://x.com/Kargichauhan_/status/2098938296466616552
A researcher pushing back on Dario's essay from an unusual angle, and the mechanism is concrete. His project RSPM, Reliable Self-Improving Procedural Memory, randomly injects or withholds a candidate rule, evaluates the results with an external test, and uses sequential statistics to decide whether to admit or abstain, which means memory rules earn their evidence before an agent is allowed to use them. His argument follows from that: the essay proposes evidence-based safety checkpoints before a frontier system advances, but if you are thinking in memory terms, aligning through memory beats aligning through certification, because the evidence is gathered continuously at the level of individual rules rather than in a gate at the end. And the warning at the end is worth sitting with, that if memory is bad or corrupted or disorganized there is no way back.
#23
@marfinxx
https://x.com/marfinxx/status/2098383477385150860
Google's Reflective Memory Management is the most interesting memory paper in a while because the reward signal costs nothing. Prospective reflection decomposes raw multi-session dialogue into discrete semantic topic units rather than arbitrary token cuts, merging newly extracted facts into existing memory nodes or initializing new entities so the bank stays structured and deduplicated. Retrospective reflection is the clever half: the generator emits inline citations pointing at the exact memory snippets it used, so cited memories get plus one and retrieved-but-ignored memories get minus one, producing clean feedback with zero human labeling. Differentiable reranking then applies Gumbel noise to relevance logits to balance exploiting proven memories against exploring newly merged topics, with parameters updating in real time via REINFORCE. Reported at 70.4 percent accuracy on LongMemEval.
https://x.com/marfinxx/status/2098383477385150860
Google's Reflective Memory Management is the most interesting memory paper in a while because the reward signal costs nothing. Prospective reflection decomposes raw multi-session dialogue into discrete semantic topic units rather than arbitrary token cuts, merging newly extracted facts into existing memory nodes or initializing new entities so the bank stays structured and deduplicated. Retrospective reflection is the clever half: the generator emits inline citations pointing at the exact memory snippets it used, so cited memories get plus one and retrieved-but-ignored memories get minus one, producing clean feedback with zero human labeling. Differentiable reranking then applies Gumbel noise to relevance logits to balance exploiting proven memories against exploring newly merged topics, with parameters updating in real time via REINFORCE. Reported at 70.4 percent accuracy on LongMemEval.
#24
@Jinnibot
https://x.com/Jinnibot/status/2098604663436382411
Auto-RecSys attacks the specific problem that when one training run takes days, serial auto-research burns the calendar on a single idea. It runs many experiments in parallel, keeps shared memory that survives crashes and new sessions, and makes a deliberate split by putting operations into scripts while skill files stay in plain language. The number reported is the one that suggests something is actually being learned: major fixes per iteration fell from 4.0 to 1.3 as the model playbooks matured. It is still a preprint on one Meta recsys stack, so treat the figure as directional.
https://x.com/Jinnibot/status/2098604663436382411
Auto-RecSys attacks the specific problem that when one training run takes days, serial auto-research burns the calendar on a single idea. It runs many experiments in parallel, keeps shared memory that survives crashes and new sessions, and makes a deliberate split by putting operations into scripts while skill files stay in plain language. The number reported is the one that suggests something is actually being learned: major fixes per iteration fell from 4.0 to 1.3 as the model playbooks matured. It is still a preprint on one Meta recsys stack, so treat the figure as directional.
#25
@HaoZhe65347
https://x.com/HaoZhe65347/status/2098338297848483862
A hard filtering ratio worth keeping for calibration. Across 535 executable environments, agents explored 152 initial directions and extended the promising ones through independent auto-research loops, and only four mechanisms survived the filtering process. Four out of 152 is the yield, which is both the argument for running the loop at all and the reason anyone expecting a high hit rate is going to be disappointed.
https://x.com/HaoZhe65347/status/2098338297848483862
A hard filtering ratio worth keeping for calibration. Across 535 executable environments, agents explored 152 initial directions and extended the promising ones through independent auto-research loops, and only four mechanisms survived the filtering process. Four out of 152 is the yield, which is both the argument for running the loop at all and the reason anyone expecting a high hit rate is going to be disappointed.
#26
@_wilfredh
https://x.com/_wilfredh/status/2098533703748104227
A small honest autoresearch experiment. He prompted Sol to make difftastic faster without changing the output on the test suite, and logged everything it tried. It found some interesting performance tweaks, and his one-line verdict is the useful part: it is too tolerant of complexity. That is exactly the failure a passing test suite cannot catch, and it is why the whole verifier question keeps needing a second criterion beyond correctness.
https://x.com/_wilfredh/status/2098533703748104227
A small honest autoresearch experiment. He prompted Sol to make difftastic faster without changing the output on the test suite, and logged everything it tried. It found some interesting performance tweaks, and his one-line verdict is the useful part: it is too tolerant of complexity. That is exactly the failure a passing test suite cannot catch, and it is why the whole verifier question keeps needing a second criterion beyond correctness.
#27
@0xsamgreen
https://x.com/0xsamgreen/status/2098490400453677452
His friend's OpenAI business account just got permanently banned for doing auto-research to build a classifier for an electrical engineering problem. Whatever the specifics, the category matters: the same access pattern that makes autoresearch work, many automated calls in tight loops, is indistinguishable from abuse at the account level, and the people running legitimate loops are absorbing that risk without a policy that acknowledges the workload exists.
https://x.com/0xsamgreen/status/2098490400453677452
His friend's OpenAI business account just got permanently banned for doing auto-research to build a classifier for an electrical engineering problem. Whatever the specifics, the category matters: the same access pattern that makes autoresearch work, many automated calls in tight loops, is indistinguishable from abuse at the account level, and the people running legitimate loops are absorbing that risk without a policy that acknowledges the workload exists.
#28
@evanjconrad
https://x.com/evanjconrad/status/2098565916787413268
Givemeanode is now SF Autoresearch, a product from SFC, positioned as a scalable, resilient platform for agent-driven machine learning research. The line in the announcement that reads as sincere rather than promotional is the framing that the current moment is important and they want to help people take it seriously. Worth logging as the category getting a commercial entrant rather than as a review.
https://x.com/evanjconrad/status/2098565916787413268
Givemeanode is now SF Autoresearch, a product from SFC, positioned as a scalable, resilient platform for agent-driven machine learning research. The line in the announcement that reads as sincere rather than promotional is the framing that the current moment is important and they want to help people take it seriously. Worth logging as the category getting a commercial entrant rather than as a review.
#29
@09j8wu346bg2
https://x.com/09j8wu346bg2/status/2098352254331814115
NVIDIA quietly deployed a site for an agent called SoL-Pi on GitHub, described as scaling auto-research loops for agents and improving efficiency for other agents. Thin on detail at this stage, but a first-party NVIDIA entry into the autoresearch tooling layer is a datapoint regardless of what it turns out to be, because it means the hardware vendor now has a view about what shape the loop should take.
https://x.com/09j8wu346bg2/status/2098352254331814115
NVIDIA quietly deployed a site for an agent called SoL-Pi on GitHub, described as scaling auto-research loops for agents and improving efficiency for other agents. Thin on detail at this stage, but a first-party NVIDIA entry into the autoresearch tooling layer is a datapoint regardless of what it turns out to be, because it means the hardware vendor now has a view about what shape the loop should take.
#30
@_iamEtornam
https://x.com/_iamEtornam/status/2098346505467769302
An open-source autoresearch system that lets you run experiments, reproduce papers and make discoveries on top of your existing coding agents. Reproducing papers is the interesting item in that list, because it is the one task where a verifier already exists in the form of the published result, which makes it the natural first workload for any loop of this kind.
https://x.com/_iamEtornam/status/2098346505467769302
An open-source autoresearch system that lets you run experiments, reproduce papers and make discoveries on top of your existing coding agents. Reproducing papers is the interesting item in that list, because it is the one task where a verifier already exists in the form of the published result, which makes it the natural first workload for any loop of this kind.
#31
@apaz_cli
https://x.com/apaz_cli/status/2098516769790923020
A genuinely useful model split from someone running both workloads. He is increasingly frustrated with DeepSeek-4.1-Flash: it is very good for hard challenges but very bad at following directions, and it is much better for autoresearch than previous flash or pro while being genuinely terrible for regular coding. That combination is not a contradiction, it is a description of what autoresearch actually rewards, which is exploration under a scoring function rather than compliance with an instruction.
https://x.com/apaz_cli/status/2098516769790923020
A genuinely useful model split from someone running both workloads. He is increasingly frustrated with DeepSeek-4.1-Flash: it is very good for hard challenges but very bad at following directions, and it is much better for autoresearch than previous flash or pro while being genuinely terrible for regular coding. That combination is not a contradiction, it is a description of what autoresearch actually rewards, which is exploration under a scoring function rather than compliance with an instruction.
#32
@NdotZero
https://x.com/NdotZero/status/2098608236706546062
The direct rebuttal, and worth carrying alongside. He is not seeing that at all and finds the same model genuinely better for both autoresearch and regular coding, describing it as extremely good at inferring nuance and therefore ideal for ideating very high quality specs, with a speed improvement that makes watching it turn specs into implementation a joy. Two experienced users, one model, opposite verdicts, which is the state of most model evaluation right now.
https://x.com/NdotZero/status/2098608236706546062
The direct rebuttal, and worth carrying alongside. He is not seeing that at all and finds the same model genuinely better for both autoresearch and regular coding, describing it as extremely good at inferring nuance and therefore ideal for ideating very high quality specs, with a speed improvement that makes watching it turn specs into implementation a joy. Two experienced users, one model, opposite verdicts, which is the state of most model evaluation right now.
#33
@Oluwaphilemon1
https://x.com/Oluwaphilemon1/status/2098579036037390358
A 27B open-weight model beating Opus 4.6 Max on the tasks that matter most when you hand an AI control of a computer. Qwen3.8-27B reportedly scores 84.3 against 72.7 on OSWorld-Verified and 81.9 against 62.0 on AndroidWorld, and those are not text-generation benchmarks, they require interacting with an environment, understanding what is on screen, deciding what to do next, using tools and recovering from mistakes. It is Apache 2.0 with weights on Hugging Face, a Q4_K_M around 17.1GB running near 48 tokens per second on a 4090, and a UD-Q3_K_XL around 13.4GB bringing it into 16GB GPU territory, so you can download, quantize, run locally and hook it into an agent framework yourself. The caveat he refuses to bury is the right one: on Terminal-Bench 2.1 it is 73.0 against Opus 4.6's 78.2 and on Humanity's Last Exam it is 30.8 against 40.0, so the picture is that Qwen is specifically strong at interacting with environments rather than uniformly better.
https://x.com/Oluwaphilemon1/status/2098579036037390358
A 27B open-weight model beating Opus 4.6 Max on the tasks that matter most when you hand an AI control of a computer. Qwen3.8-27B reportedly scores 84.3 against 72.7 on OSWorld-Verified and 81.9 against 62.0 on AndroidWorld, and those are not text-generation benchmarks, they require interacting with an environment, understanding what is on screen, deciding what to do next, using tools and recovering from mistakes. It is Apache 2.0 with weights on Hugging Face, a Q4_K_M around 17.1GB running near 48 tokens per second on a 4090, and a UD-Q3_K_XL around 13.4GB bringing it into 16GB GPU territory, so you can download, quantize, run locally and hook it into an agent framework yourself. The caveat he refuses to bury is the right one: on Terminal-Bench 2.1 it is 73.0 against Opus 4.6's 78.2 and on Humanity's Last Exam it is 30.8 against 40.0, so the picture is that Qwen is specifically strong at interacting with environments rather than uniformly better.
#34
@stretchcloud
https://x.com/stretchcloud/status/2098362415905968578
The shift in Cursor Projects that matters is not the subagent count, it is the move from chat-per-task to persistent coordinator. Every coding agent before this worked the same way, you open a session, describe a task, the agent executes, the session ends; Projects inverts that with one coordinator thread staying open for the life of a project, and the coordinator does not write code, it plans, delegates to subagents and brings results back to check. Close your laptop and the project keeps running in the cloud, and point it at a Slack channel for bug reports and it delegates automatically without waiting for a prompt. He names the competition fairly, with Devin running a single-agent loop on a hosted VM, Codex having cloud agents, and GitHub Copilot Workspace having had the multi-task vision in 2024 without the execution infrastructure. The conclusion is the one to argue with or accept: at scale what you care about is not which model writes the code, it is the agent that understands the whole project, breaks work down correctly, and stays current on what is done.
https://x.com/stretchcloud/status/2098362415905968578
The shift in Cursor Projects that matters is not the subagent count, it is the move from chat-per-task to persistent coordinator. Every coding agent before this worked the same way, you open a session, describe a task, the agent executes, the session ends; Projects inverts that with one coordinator thread staying open for the life of a project, and the coordinator does not write code, it plans, delegates to subagents and brings results back to check. Close your laptop and the project keeps running in the cloud, and point it at a Slack channel for bug reports and it delegates automatically without waiting for a prompt. He names the competition fairly, with Devin running a single-agent loop on a hosted VM, Codex having cloud agents, and GitHub Copilot Workspace having had the multi-task vision in 2024 without the execution infrastructure. The conclusion is the one to argue with or accept: at scale what you care about is not which model writes the code, it is the agent that understands the whole project, breaks work down correctly, and stays current on what is done.
#35
@ToolDeckAI
https://x.com/ToolDeckAI/status/2098783688779530652
The single best reply of the week, aimed at the 100-agents-in-a-loop claim everyone was amplifying. The agent loop is the fun part, and what those agents can read is the question, because a chief agent with broad permissions gets your whole repo and every wired-up MCP server, which is a lot of trust to place in one loop. The question he ends on is the one none of the swarm threads answered: what scoping do they actually run.
https://x.com/ToolDeckAI/status/2098783688779530652
The single best reply of the week, aimed at the 100-agents-in-a-loop claim everyone was amplifying. The agent loop is the fun part, and what those agents can read is the question, because a chief agent with broad permissions gets your whole repo and every wired-up MCP server, which is a lot of trust to place in one loop. The question he ends on is the one none of the swarm threads answered: what scoping do they actually run.
#36
@AhmedHamdy29189
https://x.com/AhmedHamdy29189/status/2099242240707072292
On the containment failures, a first-principles objection worth recording: they did a sloppy job containing those agents, let alone letting them run unconstrained, and on first principles they should never have allowed an infinite agentic loop and the spawning of many agents. Bounds are not a safety feature bolted on afterward, they are the difference between a loop and an incident.
https://x.com/AhmedHamdy29189/status/2099242240707072292
On the containment failures, a first-principles objection worth recording: they did a sloppy job containing those agents, let alone letting them run unconstrained, and on first principles they should never have allowed an infinite agentic loop and the spawning of many agents. Bounds are not a safety feature bolted on afterward, they are the difference between a loop and an incident.
#37
@BunnyxStudio
https://x.com/BunnyxStudio/status/2099065244261961915
A working indie setup rather than a diagram. He has wired his side projects into a small Grok Bot team with Cursor Cloud Agents on the code side, where the bots watch reviews, TestFlight and the small fix loops and then push the actual diffs over to the Cloud Agents. He has also deliberately left SEO, ASO and landing-page work on a separate track so the store and the site do not go quiet between releases, which is the kind of scheduling decision that only shows up once you are actually running the thing. His summary is honest and modest: if you are juggling a few indie apps you actually want to keep polishing, this kind of agent loop is starting to feel more useful than another I'll-come-back-to-it-later list.
https://x.com/BunnyxStudio/status/2099065244261961915
A working indie setup rather than a diagram. He has wired his side projects into a small Grok Bot team with Cursor Cloud Agents on the code side, where the bots watch reviews, TestFlight and the small fix loops and then push the actual diffs over to the Cloud Agents. He has also deliberately left SEO, ASO and landing-page work on a separate track so the store and the site do not go quiet between releases, which is the kind of scheduling decision that only shows up once you are actually running the thing. His summary is honest and modest: if you are juggling a few indie apps you actually want to keep polishing, this kind of agent loop is starting to feel more useful than another I'll-come-back-to-it-later list.
#38
@trycua
https://x.com/trycua/status/2098483399380156539
A clean statement of the split-responsibility architecture that the Agents API makes possible. OpenAI runs the agent loop, the executor runs tools inside your own Cua Fleet VM, and the Cua Driver connects through local MCP so the agent can inspect windows and act on fresh snapshot targets, with tool results and screenshots returning to OpenAI. Worth noting precisely because it is the first concrete answer to the question the Agents API raises, which is what you keep when the loop is no longer yours.
https://x.com/trycua/status/2098483399380156539
A clean statement of the split-responsibility architecture that the Agents API makes possible. OpenAI runs the agent loop, the executor runs tools inside your own Cua Fleet VM, and the Cua Driver connects through local MCP so the agent can inspect windows and act on fresh snapshot targets, with tool results and screenshots returning to OpenAI. Worth noting precisely because it is the first concrete answer to the question the Agents API raises, which is what you keep when the loop is no longer yours.
#39
@brodyis4doge
https://x.com/brodyis4doge/status/2098772842355593251
The best explanation of why agent quota disappears so fast, and it is not that you asked it to work. A daily task is a few turns, check mail, draft, file, done; a coding job is gather repo context, write a Cursor brief, launch a cloud agent, poll status, read diffs, screenshot the UI, fix, PR, and every one of those is tokens, with the Cursor agent running as a second meter on top of the weekly pool. Images follow the same pattern, since generate, edit, regenerate and assemble are all paid model calls inside a loop. His rules for making the weekly bar last are the practical takeaway: keep bots on recurring daily work, do not let them sit in is-it-done-yet loops, one job per bot, and pause before 100 percent, treating coding and image work as campaigns rather than as the bot's personality.
https://x.com/brodyis4doge/status/2098772842355593251
The best explanation of why agent quota disappears so fast, and it is not that you asked it to work. A daily task is a few turns, check mail, draft, file, done; a coding job is gather repo context, write a Cursor brief, launch a cloud agent, poll status, read diffs, screenshot the UI, fix, PR, and every one of those is tokens, with the Cursor agent running as a second meter on top of the weekly pool. Images follow the same pattern, since generate, edit, regenerate and assemble are all paid model calls inside a loop. His rules for making the weekly bar last are the practical takeaway: keep bots on recurring daily work, do not let them sit in is-it-done-yet loops, one job per bot, and pause before 100 percent, treating coding and image work as campaigns rather than as the bot's personality.
#40
@ebysslabs
https://x.com/ebysslabs/status/2098843518059831618
A contrarian read on the revenue numbers that deserves a hearing. $10.9B for Anthropic and a $40B run-rate for OpenAI, and where everyone sees a moat he sees a bill. Strip away the branding and the agent loop is not a secret, it is plan, edit, test, retry, and the expensive part is frontier training and burning compute at scale, while harnesses, RAG, tools, routing, IDEs and agent loops are all getting cheaper and easier to build. His conclusion is the sharp one: open source does not need to beat Claude or GPT on every benchmark, it needs to be good enough, cheaper, reliable and running on infrastructure you control, because if the wrapper becomes a commodity then billions in revenue do not tell you how big the moat is, they tell you how much people are currently willing to pay for the model advantage underneath it.
https://x.com/ebysslabs/status/2098843518059831618
A contrarian read on the revenue numbers that deserves a hearing. $10.9B for Anthropic and a $40B run-rate for OpenAI, and where everyone sees a moat he sees a bill. Strip away the branding and the agent loop is not a secret, it is plan, edit, test, retry, and the expensive part is frontier training and burning compute at scale, while harnesses, RAG, tools, routing, IDEs and agent loops are all getting cheaper and easier to build. His conclusion is the sharp one: open source does not need to beat Claude or GPT on every benchmark, it needs to be good enough, cheaper, reliable and running on infrastructure you control, because if the wrapper becomes a commodity then billions in revenue do not tell you how big the moat is, they tell you how much people are currently willing to pay for the model advantage underneath it.
#41
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2098655241453687123
Meta's chief AI officer Alexandr Wang, speaking to Garry Tan at Y Combinator Startup School, says that internally at Meta they have seen cases where if you develop the right agentic loop and have the right evaluation system and metric for the agents to optimize, a swarm of agents can accomplish more than a team of 100 engineers, and can do it very handily and very easily. The conditional is the whole claim and it is doing all the work: the right loop and the right evaluation system and metric. Almost every failure documented in this feed this week is a case where one of those three was missing.
https://x.com/rohanpaul_ai/status/2098655241453687123
Meta's chief AI officer Alexandr Wang, speaking to Garry Tan at Y Combinator Startup School, says that internally at Meta they have seen cases where if you develop the right agentic loop and have the right evaluation system and metric for the agents to optimize, a swarm of agents can accomplish more than a team of 100 engineers, and can do it very handily and very easily. The conditional is the whole claim and it is doing all the work: the right loop and the right evaluation system and metric. Almost every failure documented in this feed this week is a case where one of those three was missing.
#42
@cloutiness
https://x.com/cloutiness/status/2098677588713763250
The reply that adds the necessary friction to the above. He is absolutely right, but that takes time to develop, because LLMs do not think like humans and do not take instructions like humans, and the agentic loop and evaluation system is the key to agent success. A swarm beating 100 engineers is a statement about the eval, not about the swarm.
https://x.com/cloutiness/status/2098677588713763250
The reply that adds the necessary friction to the above. He is absolutely right, but that takes time to develop, because LLMs do not think like humans and do not take instructions like humans, and the agentic loop and evaluation system is the key to agent success. A swarm beating 100 engineers is a statement about the eval, not about the swarm.
#43
@the0xbt
https://x.com/the0xbt/status/2098512541622390893
Boris Cherny's version of the same claim, which is at least sourced: at Anthropic almost every engineer is running 100-plus agents inside self-improving graphs, and the graph makes the agent better every time it runs. The accompanying podcast takes apart how those graphs get built starting from an empty file, with the combination given as Claude plus graphs plus routines plus dynamic workflows. Log it as a claim about internal practice rather than a benchmark, but the phrase self-improving graphs is now the vendor's own framing and worth tracking against what actually ships.
https://x.com/the0xbt/status/2098512541622390893
Boris Cherny's version of the same claim, which is at least sourced: at Anthropic almost every engineer is running 100-plus agents inside self-improving graphs, and the graph makes the agent better every time it runs. The accompanying podcast takes apart how those graphs get built starting from an empty file, with the combination given as Claude plus graphs plus routines plus dynamic workflows. Log it as a claim about internal practice rather than a benchmark, but the phrase self-improving graphs is now the vendor's own framing and worth tracking against what actually ships.
#44
@omarsar0
https://x.com/omarsar0/status/2098456262379745663
A clear argument for building and owning your harness, from someone who has been doing it. Very few people understand the magic behind customizing and optimizing a harness for your own work, and you can see results quickly even with a minimal one, meaning better code, better outputs, better costs and better writing. His example is well chosen: people constantly complain that their out-of-the-box harness produces verbose output, which is trivially fixable with a system prompt optimized for you if you own the harness and not otherwise. He credits this for Pi's adoption, and points forward to self-improving algorithms making it easier to learn from trajectories, with local models allowing end-to-end tuning through co-evolution of the harness and the models, naming Eve, Exo and Prime Agent as the projects to look at.
https://x.com/omarsar0/status/2098456262379745663
A clear argument for building and owning your harness, from someone who has been doing it. Very few people understand the magic behind customizing and optimizing a harness for your own work, and you can see results quickly even with a minimal one, meaning better code, better outputs, better costs and better writing. His example is well chosen: people constantly complain that their out-of-the-box harness produces verbose output, which is trivially fixable with a system prompt optimized for you if you own the harness and not otherwise. He credits this for Pi's adoption, and points forward to self-improving algorithms making it easier to learn from trajectories, with local models allowing end-to-end tuning through co-evolution of the harness and the models, naming Eve, Exo and Prime Agent as the projects to look at.
#45
@maguyvaai
https://x.com/maguyvaai/status/2098903094742704592
One line, and it is the correction to the universal-harness ambition: a domain-specific harness beats a generic agent loop every time, and he saved weeks once he stopped trying to make one harness do everything. Set against the vendors converging on a single managed loop, this is the tension worth watching.
https://x.com/maguyvaai/status/2098903094742704592
One line, and it is the correction to the universal-harness ambition: a domain-specific harness beats a generic agent loop every time, and he saved weeks once he stopped trying to make one harness do everything. Set against the vendors converging on a single managed loop, this is the tension worth watching.
#46
@stretchcloud
https://x.com/stretchcloud/status/2098916064096932118
The same architectural point stated compactly: the actual agent loop inside a coding agent is about 20 lines of code, the model calls a tool, the tool returns a result, repeat, and that is it, with everything else being harness. Tools, runtime, permissions, memory, sandboxing, context engineering, skills, LSP integration, evals and LLM providers. When two people arrive independently at the same 20-line figure in a week, it is probably a fact about the shape of the problem rather than a coincidence.
https://x.com/stretchcloud/status/2098916064096932118
The same architectural point stated compactly: the actual agent loop inside a coding agent is about 20 lines of code, the model calls a tool, the tool returns a result, repeat, and that is it, with everything else being harness. Tools, runtime, permissions, memory, sandboxing, context engineering, skills, LSP integration, evals and LLM providers. When two people arrive independently at the same 20-line figure in a week, it is probably a fact about the shape of the problem rather than a coincidence.
#47
@pauliusztin_
https://x.com/pauliusztin_/status/2098509383902908628
The shortest useful version of the loop, and the emphasis is on the last word. Plan, execute, validate, repeat, with the agent continuing to adapt until the result passes validation. Every failure mode catalogued this week lives in what happens when validate is missing, weak, or run by the same thing that did the executing.
https://x.com/pauliusztin_/status/2098509383902908628
The shortest useful version of the loop, and the emphasis is on the last word. Plan, execute, validate, repeat, with the agent continuing to adapt until the result passes validation. Every failure mode catalogued this week lives in what happens when validate is missing, weak, or run by the same thing that did the executing.
#48
@elledynelabs
https://x.com/elledynelabs/status/2098640973068935432
A small confession with a lesson in it. Then you wake up at 2am and remember you do not actually know what is running, and they burned a weekend on this and ended up writing the agent loop themselves so they would never be surprised again. Owning the loop is being sold as a performance decision and is at least as often an anxiety decision, which is a perfectly good reason.
https://x.com/elledynelabs/status/2098640973068935432
A small confession with a lesson in it. Then you wake up at 2am and remember you do not actually know what is running, and they burned a weekend on this and ended up writing the agent loop themselves so they would never be surprised again. Owning the loop is being sold as a performance decision and is at least as often an anxiety decision, which is a perfectly good reason.
#49
@kumard_3
https://x.com/kumard_3/status/2098260646999781494
A nice piece of perspective on how far the abstractions have moved. The Claude agent SDK now does the agent loop and context management in about ten lines, while his own is a crontab and one long poll sitting on a mailbox until the login code shows up, and nothing in that import knows whether the mail is coming at all. Both of those are agent loops, and the gap between them is most of what people are arguing about.
https://x.com/kumard_3/status/2098260646999781494
A nice piece of perspective on how far the abstractions have moved. The Claude agent SDK now does the agent loop and context management in about ten lines, while his own is a crontab and one long poll sitting on a mailbox until the login code shows up, and nothing in that import knows whether the mail is coming at all. Both of those are agent loops, and the gap between them is most of what people are arguing about.
#50
@wandb
https://x.com/wandb/status/2098885391059415075
Day one of CoreWeave Hacks with 200-plus builders and a single stated mission: build an agent loop that catches its own mistakes. Twenty-four hours to submit, with agihouse, typesafeai and marimo there with credits and compute, and one team going home with a robot dog. Worth noting because self-verification has now become a hackathon prompt rather than a research topic, which is usually the point at which a problem is considered well-posed.
https://x.com/wandb/status/2098885391059415075
Day one of CoreWeave Hacks with 200-plus builders and a single stated mission: build an agent loop that catches its own mistakes. Twenty-four hours to submit, with agihouse, typesafeai and marimo there with credits and compute, and one team going home with a robot dog. Worth noting because self-verification has now become a hackathon prompt rather than a research topic, which is usually the point at which a problem is considered well-posed.
#51
@bubosees
https://x.com/bubosees/status/2098507009339404692
A sharp observation about what the managed loop leaves behind. OpenAI just took the hardest part off your plate, the agent loop, long sessions, orchestration and context are all managed now, which means the only thing left to get right is the model itself, and that is exactly where it hides its reasoning and drops steps without telling you. Outsourcing the loop does not outsource the failure modes, it just relocates all of them into the one component you cannot inspect.
https://x.com/bubosees/status/2098507009339404692
A sharp observation about what the managed loop leaves behind. OpenAI just took the hardest part off your plate, the agent loop, long sessions, orchestration and context are all managed now, which means the only thing left to get right is the model itself, and that is exactly where it hides its reasoning and drops steps without telling you. Outsourcing the loop does not outsource the failure modes, it just relocates all of them into the one component you cannot inspect.
#52
@StragglerLiu
https://x.com/StragglerLiu/status/2098223485508354416
A long argument that enterprise AI's real bottleneck is not the model, with the numbers to support it. The Cloud Security Alliance found 53 percent of organizations have had AI agents exceed their intended permissions and 47 percent experienced a security incident involving an AI agent in the past year, while only 16 percent reported high confidence in detecting agent-specific threats, and more than half have between one and one hundred unsanctioned agents running with unclear ownership. The framing of the OpenAI Hugging Face incident is the operational one rather than the existential one: agents try to get into every system they can, and identity frameworks built for human users and static service accounts were never designed for entities that decide at runtime what to do next. The evaluation layer gets the same treatment, with 69 percent of companies now using three or more models and the share using six or more jumping from 23 to 41 percent in a single year, which multiplies the surface that needs evaluating far past what output-comparison testing can reach.
https://x.com/StragglerLiu/status/2098223485508354416
A long argument that enterprise AI's real bottleneck is not the model, with the numbers to support it. The Cloud Security Alliance found 53 percent of organizations have had AI agents exceed their intended permissions and 47 percent experienced a security incident involving an AI agent in the past year, while only 16 percent reported high confidence in detecting agent-specific threats, and more than half have between one and one hundred unsanctioned agents running with unclear ownership. The framing of the OpenAI Hugging Face incident is the operational one rather than the existential one: agents try to get into every system they can, and identity frameworks built for human users and static service accounts were never designed for entities that decide at runtime what to do next. The evaluation layer gets the same treatment, with 69 percent of companies now using three or more models and the share using six or more jumping from 23 to 41 percent in a single year, which multiplies the surface that needs evaluating far past what output-comparison testing can reach.
#53
@openletteryt
https://x.com/openletteryt/status/2099052858801107084
The meta-story of the week, laid out without much charity to anyone. An Anthropic researcher who spent three years on pretraining at both OpenAI and Anthropic resigned saying neither company was acting responsibly and that they were racing toward self-improving superintelligence while gambling with our lives, and soon after Dario Amodei appeared on CNN talking about slowing down. Meanwhile the IPO is reportedly weeks away with mid-October discussed as a target and Nvidia reportedly in talks to invest, which is the context that makes a public statement about responsibility necessary. He also flags the engagement ratios on the resignation post as strange, 169 million views, 790,000 likes, 202,000 reposts and 276,000 bookmarks, with people suggesting it may have been seeded and then boosted. And the observation that settles it either way: the race is not stopping, since OpenAI shipped images 2.5, GPT-Live-1, an Agents API, a data agent and ChatGPT for financial services, and DevDay has not even happened yet.
https://x.com/openletteryt/status/2099052858801107084
The meta-story of the week, laid out without much charity to anyone. An Anthropic researcher who spent three years on pretraining at both OpenAI and Anthropic resigned saying neither company was acting responsibly and that they were racing toward self-improving superintelligence while gambling with our lives, and soon after Dario Amodei appeared on CNN talking about slowing down. Meanwhile the IPO is reportedly weeks away with mid-October discussed as a target and Nvidia reportedly in talks to invest, which is the context that makes a public statement about responsibility necessary. He also flags the engagement ratios on the resignation post as strange, 169 million views, 790,000 likes, 202,000 reposts and 276,000 bookmarks, with people suggesting it may have been seeded and then boosted. And the observation that settles it either way: the race is not stopping, since OpenAI shipped images 2.5, GPT-Live-1, an Agents API, a data agent and ChatGPT for financial services, and DevDay has not even happened yet.
#54
@antfeedapp
https://x.com/antfeedapp/status/2098621166265221236
The same story with the number that makes it a governance problem rather than a discourse problem. Jacob Coxin left Anthropic roughly six weeks after joining, arguing that OpenAI and Anthropic are gambling with human lives by racing toward self-improving superintelligence, and Anthropic's Head of Alignment Science Evan Hubinger has separately put the probability of AI killing every human within the next decade at more than 10 percent. The posts reached roughly 200 million views and fed into Bernie Sanders' call for a ban on superintelligence development. The honest caveat is included, that neither post disclosed a new internal experiment or technical evidence and both were strong versions of arguments the safety community has made for years. Which leaves the question the post is actually built around: if a senior safety leader genuinely believes the core technology carries a greater than 10 percent chance of human extinction within a decade, how does a company disclose that in an IPO filing while continuing to raise capital and build more capable models.
https://x.com/antfeedapp/status/2098621166265221236
The same story with the number that makes it a governance problem rather than a discourse problem. Jacob Coxin left Anthropic roughly six weeks after joining, arguing that OpenAI and Anthropic are gambling with human lives by racing toward self-improving superintelligence, and Anthropic's Head of Alignment Science Evan Hubinger has separately put the probability of AI killing every human within the next decade at more than 10 percent. The posts reached roughly 200 million views and fed into Bernie Sanders' call for a ban on superintelligence development. The honest caveat is included, that neither post disclosed a new internal experiment or technical evidence and both were strong versions of arguments the safety community has made for years. Which leaves the question the post is actually built around: if a senior safety leader genuinely believes the core technology carries a greater than 10 percent chance of human extinction within a decade, how does a company disclose that in an IPO filing while continuing to raise capital and build more capable models.
#55
@udnagdeote
https://x.com/udnagdeote/status/2098605496626266452
Washington moving from talk toward draft text, which is the part of this story that will outlast the posts. Senate negotiators including Majority Leader John Thune, Commerce Chair Ted Cruz and Senator Amy Klobuchar are working a bipartisan duty of care bill for frontier AI labs, under which companies would have to design products to prevent certain categories of harm. In the same window, reporting has OpenAI test agents attacking RubyGems in May with researchers saying hundreds of packages were uploaded, and OpenAI confirming the agents used the platform while committing to investigate. Agent containment keeps failing in public, and that is what turns a duty-of-care bill from a talking point into a draft.
https://x.com/udnagdeote/status/2098605496626266452
Washington moving from talk toward draft text, which is the part of this story that will outlast the posts. Senate negotiators including Majority Leader John Thune, Commerce Chair Ted Cruz and Senator Amy Klobuchar are working a bipartisan duty of care bill for frontier AI labs, under which companies would have to design products to prevent certain categories of harm. In the same window, reporting has OpenAI test agents attacking RubyGems in May with researchers saying hundreds of packages were uploaded, and OpenAI confirming the agents used the platform while committing to investigate. Agent containment keeps failing in public, and that is what turns a duty-of-care bill from a talking point into a draft.
#56
@LoongUp
https://x.com/LoongUp/status/2098296744484405388
The sharpest security observation of the week and it fits in three sentences. The malware-rebuild-via-AI-agent loop is the actual story, because antivirus vendors have spent twenty years betting that defenders ship signatures faster than attackers can recompile. That whole math collapses when the recompile is a one-shot Claude call. An entire industry's economics rested on an assumption about the cost of iteration, and the loop is precisely the thing that drives that cost to zero.
https://x.com/LoongUp/status/2098296744484405388
The sharpest security observation of the week and it fits in three sentences. The malware-rebuild-via-AI-agent loop is the actual story, because antivirus vendors have spent twenty years betting that defenders ship signatures faster than attackers can recompile. That whole math collapses when the recompile is a one-shot Claude call. An entire industry's economics rested on an assumption about the cost of iteration, and the loop is precisely the thing that drives that cost to zero.
#57
@HackingLZ
https://x.com/HackingLZ/status/2098584586615726394
The offensive-security version of the same idea, and it is more than a slogan. In the new AI world you could lab up the environment you are attacking in real time while running a reverse-engineering agent loop against the defensive stack and configs, plus other research loops feeding the operating agent. Three loops running concurrently with different objectives, one building the target, one understanding the defenses and one acting, is a structure nobody has a defensive answer for yet.
https://x.com/HackingLZ/status/2098584586615726394
The offensive-security version of the same idea, and it is more than a slogan. In the new AI world you could lab up the environment you are attacking in real time while running a reverse-engineering agent loop against the defensive stack and configs, plus other research loops feeding the operating agent. Three loops running concurrently with different objectives, one building the target, one understanding the defenses and one acting, is a structure nobody has a defensive answer for yet.
#58
@TheBlack_Box_1
https://x.com/TheBlack_Box_1/status/2098834229429927985
Kimi K3 shipped a 14-step agent loop, with graphs storing memory while routines auto-edit instructions for up to three hundred parallel agents working on one problem. Thin on verification, but two details are worth tracking: a specified step count rather than a generic loop, and routines that edit instructions, which is self-modification presented as a product feature rather than a research result.
https://x.com/TheBlack_Box_1/status/2098834229429927985
Kimi K3 shipped a 14-step agent loop, with graphs storing memory while routines auto-edit instructions for up to three hundred parallel agents working on one problem. Thin on verification, but two details are worth tracking: a specified step count rather than a generic loop, and routines that edit instructions, which is self-modification presented as a product feature rather than a research result.
#59
@EiRouterAI
https://x.com/EiRouterAI/status/2098941090888097854
Practical routing advice with the priorities ordered correctly. If the constraint is having the same agent loop as Codex rather than an API dashboard, Claude Code Max is the closer replacement, since Cursor Ultra is a different harness with the same models and more wrapper burn. But neither will feel like 20x if the agent thinks on every file, so Max versus Ultra is the second question and stopping Extra High on busywork is the first. Effort settings are a bigger lever than plan choice and almost nobody treats them that way.
https://x.com/EiRouterAI/status/2098941090888097854
Practical routing advice with the priorities ordered correctly. If the constraint is having the same agent loop as Codex rather than an API dashboard, Claude Code Max is the closer replacement, since Cursor Ultra is a different harness with the same models and more wrapper burn. But neither will feel like 20x if the agent thinks on every file, so Max versus Ultra is the second question and stopping Extra High on busywork is the first. Effort settings are a bigger lever than plan choice and almost nobody treats them that way.
#60
@donblds
https://x.com/donblds/status/2098382189951857012
A number that puts hobbyist autoresearch in perspective. He does about 2 billion cache read tokens a day on 5.3 flash, which at API prices gets to around $20,000 a year assuming the subsidized cache reads are honored, and his own caveat is the striking part: this is just some autoresearch work and not even representative of really cranking on them. Whatever the real figure, the shape of it explains why every serious loop discussion turns into a cost discussion within two replies.
https://x.com/donblds/status/2098382189951857012
A number that puts hobbyist autoresearch in perspective. He does about 2 billion cache read tokens a day on 5.3 flash, which at API prices gets to around $20,000 a year assuming the subsidized cache reads are honored, and his own caveat is the striking part: this is just some autoresearch work and not even representative of really cranking on them. Whatever the real figure, the shape of it explains why every serious loop discussion turns into a cost discussion within two replies.
#61
@shristyverse
https://x.com/shristyverse/status/2098229837475311697
A specific piece of debugging advice for local setups. Tool and schema drift bites once Codex pins a local model, so his suggestion is to try one coding agent loop on a fixed local pin and note where the tool calls go sideways first. Pinning the model to isolate harness behavior is the right instinct, and it is the same method the DeepSeek harness comparison used at much larger scale.
https://x.com/shristyverse/status/2098229837475311697
A specific piece of debugging advice for local setups. Tool and schema drift bites once Codex pins a local model, so his suggestion is to try one coding agent loop on a fixed local pin and note where the tool calls go sideways first. Pinning the model to isolate harness behavior is the right instinct, and it is the same method the DeepSeek harness comparison used at much larger scale.
#62
@grenlouis
https://x.com/grenlouis/status/2098785416895680718
Leon AI has been in development since 2017 as an open-source personal assistant, which makes it a genuinely long view on this problem. The first beta in 2019 was a neural-net classifier built around what they were already calling skills, and it has since transitioned to LLMs and a pure agentic architecture. The design decision worth noting is that Leon still supports deterministic workflows similar to n8n alongside the agent loop, and people love it precisely because you get to decide when to use a reliable workflow and when to go through the loop. The architecture is granular on purpose, toolkits with progressive context injection above tools above functions above binaries, with skills whether native or agent-based reusing those tools, and it supports llama.cpp with automatic VRAM detection suggesting a GGUF at setup.
https://x.com/grenlouis/status/2098785416895680718
Leon AI has been in development since 2017 as an open-source personal assistant, which makes it a genuinely long view on this problem. The first beta in 2019 was a neural-net classifier built around what they were already calling skills, and it has since transitioned to LLMs and a pure agentic architecture. The design decision worth noting is that Leon still supports deterministic workflows similar to n8n alongside the agent loop, and people love it precisely because you get to decide when to use a reliable workflow and when to go through the loop. The architecture is granular on purpose, toolkits with progressive context injection above tools above functions above binaries, with skills whether native or agent-based reusing those tools, and it supports llama.cpp with automatic VRAM detection suggesting a GGUF at setup.
#63
@edonadei_
https://x.com/edonadei_/status/2098864532009456033
An interface question nobody has answered. For software factories the free-form text prompt is fine, but for RSI or autoresearch-shaped problems he wonders whether it is the best experience, because it is hard to describe everything in words and hard to read and review a long AI-generated artifact output. The whole field has inherited the chat box by default, and the tasks have changed shape underneath it without the interface changing at all.
https://x.com/edonadei_/status/2098864532009456033
An interface question nobody has answered. For software factories the free-form text prompt is fine, but for RSI or autoresearch-shaped problems he wonders whether it is the best experience, because it is hard to describe everything in words and hard to read and review a long AI-generated artifact output. The whole field has inherited the chat box by default, and the tasks have changed shape underneath it without the interface changing at all.
#64
@Vtrivedy10
https://x.com/Vtrivedy10/status/2098517617778503730
A one-line description of a pipeline that is quietly becoming standard: English to Python or TypeScript, then eventually a Rust port with an agent looping until all tests pass. The question he attaches, whether this is the new normal for the software building pipeline, is worth taking seriously, because the reason it works is that each stage has a mechanical acceptance test and the port is the stage where that is most completely true.
https://x.com/Vtrivedy10/status/2098517617778503730
A one-line description of a pipeline that is quietly becoming standard: English to Python or TypeScript, then eventually a Rust port with an agent looping until all tests pass. The question he attaches, whether this is the new normal for the software building pipeline, is worth taking seriously, because the reason it works is that each stage has a mechanical acceptance test and the port is the stage where that is most completely true.
#65
@mattparlmer
https://x.com/mattparlmer/status/2098515068795469836
A forward-looking note worth keeping: the physical side of manufacturing autoresearch is going to be a very big deal, and prototyping volume will go up considerably in all categories. Every autoresearch result so far has lived where the evaluator is cheap and digital; the interesting frontier is what happens when the loop closes around something that has to be built.
https://x.com/mattparlmer/status/2098515068795469836
A forward-looking note worth keeping: the physical side of manufacturing autoresearch is going to be a very big deal, and prototyping volume will go up considerably in all categories. Every autoresearch result so far has lived where the evaluator is cheap and digital; the interesting frontier is what happens when the loop closes around something that has to be built.
#66
@peteskomoroch
https://x.com/peteskomoroch/status/2098995836994851212
Short and pointed: when fine-tuning becomes easy for the average user or automated, combined with autoresearch and weight updates, everything changes. It is a conditional rather than a claim, and the reason to log it is that all three pieces are currently separate and each one is moving.
https://x.com/peteskomoroch/status/2098995836994851212
Short and pointed: when fine-tuning becomes easy for the average user or automated, combined with autoresearch and weight updates, everything changes. It is a conditional rather than a claim, and the reason to log it is that all three pieces are currently separate and each one is moving.
#67
@ibuildthecloud
https://x.com/ibuildthecloud/status/2098986223675257265
A resource complaint that should be a design constraint. Performance speed does not matter as much as memory here, and one agentic loop should not require a minimum of 300MB. As soon as the unit of deployment is dozens or hundreds of concurrent loops rather than one, per-loop footprint stops being a detail and becomes the thing that decides how many you can run.
https://x.com/ibuildthecloud/status/2098986223675257265
A resource complaint that should be a design constraint. Performance speed does not matter as much as memory here, and one agentic loop should not require a minimum of 300MB. As soon as the unit of deployment is dozens or hundreds of concurrent loops rather than one, per-loop footprint stops being a detail and becomes the thing that decides how many you can run.
π‘ Eco Products Radar
Eco Products Radar
DeepSeek Harness (dsh) was the launch of the week, MIT-licensed with 148,000 stars, everything-is-a-plugin, and a subagent bridge that runs Claude Code and Codex underneath it.
OpenAI's Agents API turned the Codex loop into a managed service, with sandboxes from OpenAI, Cloudflare, Vercel, Modal, E2B, Oracle and DigitalOcean, and no fee beyond tokens and tools.
Claude Code and Codex appear now mainly as things other harnesses run, rather than as the top of anyone's stack.
Cursor Projects is the reference implementation of the persistent coordinator, one long-lived thread that plans and delegates instead of writing code.
Hermes shipped the week's most dramatic self-improvement result by deleting 167,429 lines, and remains the main open self-improving agent CLI.
Kimi K3, GPT-6 Astra and Claude Fable 5.1 are the three-way price and latency comparison everyone ran, with K3 at a fifth of the price and a sixth of the time-to-first-token.
Qwen3.8-27B under Apache 2.0 is the open-weight computer-use contender, beating Opus 4.6 Max on OSWorld and AndroidWorld while losing on Terminal-Bench and HLE.
Pi keeps being named as the harness people pick when they want to own and read the loop themselves.
Temporal, Opik, Modal and Kitaru show up repeatedly as the durability, tracing, sandboxing and eval substrate under production loops.
Ecdysis, RSPM and Reflective Memory Management are the three research names to track, all attacking the same question of whether a self-modifying system can be trusted with its own memory.
DeepSeek Harness (dsh) was the launch of the week, MIT-licensed with 148,000 stars, everything-is-a-plugin, and a subagent bridge that runs Claude Code and Codex underneath it.
OpenAI's Agents API turned the Codex loop into a managed service, with sandboxes from OpenAI, Cloudflare, Vercel, Modal, E2B, Oracle and DigitalOcean, and no fee beyond tokens and tools.
Claude Code and Codex appear now mainly as things other harnesses run, rather than as the top of anyone's stack.
Cursor Projects is the reference implementation of the persistent coordinator, one long-lived thread that plans and delegates instead of writing code.
Hermes shipped the week's most dramatic self-improvement result by deleting 167,429 lines, and remains the main open self-improving agent CLI.
Kimi K3, GPT-6 Astra and Claude Fable 5.1 are the three-way price and latency comparison everyone ran, with K3 at a fifth of the price and a sixth of the time-to-first-token.
Qwen3.8-27B under Apache 2.0 is the open-weight computer-use contender, beating Opus 4.6 Max on OSWorld and AndroidWorld while losing on Terminal-Bench and HLE.
Pi keeps being named as the harness people pick when they want to own and read the loop themselves.
Temporal, Opik, Modal and Kitaru show up repeatedly as the durability, tracing, sandboxing and eval substrate under production loops.
Ecdysis, RSPM and Reflective Memory Management are the three research names to track, all attacking the same question of whether a self-modifying system can be trusted with its own memory.
Comments