Loop Daily: 2026-09-13
The open version of the loop got its paper today, and it says what made it work: 100-plus people and their agents spent two months on one secp256k1 quantum-circuit problem and beat Google Quantum AI's published score by better than 50 percent, held together by a machine-checkable verifier and a public leaderboard. Set against that, the field got its first serious negative result about self-improvement. A paper called Ecdysis inspected what agents actually change when they rewrite their own harness, and found that 60 percent of normal self-evolution edits are just accommodations for quirks of the current model β one local mistake becomes permanent infrastructure. The other movement was commercial: the loop stopped being something you build and became something you rent, with OpenAI putting the Codex harness behind an API, Cursor shipping a persistent coordinator, Coder going GA fully self-hosted, and every one of those choices reducing to the same question of who operates the harness and where the code actually runs. Underneath all of it, verification keeps showing up as the bottleneck nobody can demo, including the version nobody has answered: who verifies the harness's own edits.
#1
@jieyilong
https://x.com/jieyilong/status/2098057343057727789
The first full paper on open autoresearch is out, and it documents a result rather than a method. Over roughly two months, more than 100 participants and their agents attacked one problem: optimizing a quantum circuit for point-addition on secp256k1, the elliptic curve behind Bitcoin and Ethereum. Point-addition is the major bottleneck in implementing Shor's algorithm for elliptic curves, so pushing its cost down tells you how much runway the migration actually has. The circuit they collectively produced uses 1,151 logical qubits and 1.30 million Toffoli gates, beating Google Quantum AI's published Q x T score by more than 50 percent. What began as one person exploring quantum-circuit optimization with agents turned into a collaboration across quantum computing, cryptography, Web3 and systems research.
https://x.com/jieyilong/status/2098057343057727789
The first full paper on open autoresearch is out, and it documents a result rather than a method. Over roughly two months, more than 100 participants and their agents attacked one problem: optimizing a quantum circuit for point-addition on secp256k1, the elliptic curve behind Bitcoin and Ethereum. Point-addition is the major bottleneck in implementing Shor's algorithm for elliptic curves, so pushing its cost down tells you how much runway the migration actually has. The circuit they collectively produced uses 1,151 logical qubits and 1.30 million Toffoli gates, beating Google Quantum AI's published Q x T score by more than 50 percent. What began as one person exploring quantum-circuit optimization with agents turned into a collaboration across quantum computing, cryptography, Web3 and systems research.
#2
@mitchliu
https://x.com/mitchliu/status/2098135964388581689
The sharpest read on why that result matters, and it isn't the 50 percent. Traditionally research productivity is capped by the number of researchers. Autoresearch instead scales with compute, models, orchestration and evaluation harnesses: agents run iterative experimentation around the clock, improvements are verified automatically, and the community builds on the latest result instead of waiting for the next paper. What they actually pioneered is a model of scientific research where thousands of distributed humans and AI agents collaborate and compete on a hard problem continuously.
https://x.com/mitchliu/status/2098135964388581689
The sharpest read on why that result matters, and it isn't the 50 percent. Traditionally research productivity is capped by the number of researchers. Autoresearch instead scales with compute, models, orchestration and evaluation harnesses: agents run iterative experimentation around the clock, improvements are verified automatically, and the community builds on the latest result instead of waiting for the next paper. What they actually pioneered is a model of scientific research where thousands of distributed humans and AI agents collaborate and compete on a hard problem continuously.
#3
@nasqret
https://x.com/nasqret/status/2098145816007655475
A participant's account of what the community actually was. This is probably the first massively collaborative project in the world that gathered people running auto-research loops with agents and pointed all of them at one specific task: designing a quantum algorithm implementing a variant of Shor's for the discrete logarithm problem on secp256k1 curve addition. What formed around it was a community of researchers studying agent coordination, staying in the loop, exchanging ideas and pushing the frontier β competitive and collaborative at the same time.
https://x.com/nasqret/status/2098145816007655475
A participant's account of what the community actually was. This is probably the first massively collaborative project in the world that gathered people running auto-research loops with agents and pointed all of them at one specific task: designing a quantum algorithm implementing a variant of Shor's for the discrete logarithm problem on secp256k1 curve addition. What formed around it was a community of researchers studying agent coordination, staying in the loop, exchanging ideas and pushing the frontier β competitive and collaborative at the same time.
#4
@eigenlabs
https://x.com/eigenlabs/status/2098526938214310339
The credit note that names the mechanism. The leaderboard is still live, and Eigen Labs built the leaderboard and the verifier-gated process behind it. What made it work was 100+ researchers and their agents showing up over eight weeks, sharing what worked and what didn't, and building on each other. Coauthors span Theta Network, the Ethereum Foundation, StarkWare, Starknet, Trail of Bits, Brevis, Sei, the Pauli Group, OctavFi, Adam Mickiewicz University in PoznaΕ, Warsaw University of Technology and Stanford's Free Systems Lab. Verifier plus public leaderboard is the entire recipe.
https://x.com/eigenlabs/status/2098526938214310339
The credit note that names the mechanism. The leaderboard is still live, and Eigen Labs built the leaderboard and the verifier-gated process behind it. What made it work was 100+ researchers and their agents showing up over eight weeks, sharing what worked and what didn't, and building on each other. Coauthors span Theta Network, the Ethereum Foundation, StarkWare, Starknet, Trail of Bits, Brevis, Sei, the Pauli Group, OctavFi, Adam Mickiewicz University in PoznaΕ, Warsaw University of Technology and Stanford's Free Systems Lab. Verifier plus public leaderboard is the entire recipe.
#5
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2098655241453687123
Meta's chief AI officer, talking to Y Combinator's CEO at Startup School, gave the most aggressive internal claim of the window and put two conditions on it. 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 do it handily. The conditional clause is the whole sentence: the right loop, and a metric the agents can optimize against.
https://x.com/rohanpaul_ai/status/2098655241453687123
Meta's chief AI officer, talking to Y Combinator's CEO at Startup School, gave the most aggressive internal claim of the window and put two conditions on it. 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 do it handily. The conditional clause is the whole sentence: the right loop, and a metric the agents can optimize against.
#6
@omarsar0
https://x.com/omarsar0/status/2098456262379745663
A direct argument for owning your harness, with a specific example of what it buys you. Very few people understand the magic behind customizing and optimizing an agent harness for your own work, and you start seeing results quickly even with a minimal one: better code, better outputs, better costs, better writing. His example is the most common complaint, people tired of out-of-the-box harnesses producing verbose output, which is trivially fixed with a system prompt you actually control. He argues this is why Pi is seeing the adoption it is, and that with local models you can tune the whole thing end to end through a co-evolution of harness and model.
https://x.com/omarsar0/status/2098456262379745663
A direct argument for owning your harness, with a specific example of what it buys you. Very few people understand the magic behind customizing and optimizing an agent harness for your own work, and you start seeing results quickly even with a minimal one: better code, better outputs, better costs, better writing. His example is the most common complaint, people tired of out-of-the-box harnesses producing verbose output, which is trivially fixed with a system prompt you actually control. He argues this is why Pi is seeing the adoption it is, and that with local models you can tune the whole thing end to end through a co-evolution of harness and model.
#7
@pauliusztin_
https://x.com/pauliusztin_/status/2098750979353063495
Someone building a coding agent from scratch reports the most useful thing he has learned so far: the LLM is probably the smallest part of a good agent. The core loop is surprisingly small, reason, act, observe, repeat. What that loop alone doesn't give you is production readiness, which means controlling what context reaches the model and how it gets compressed, which tools it can access, which actions can run versus need approval, where tools execute and how memory persists and how you operate sandboxes and subagents, and how you trace, debug, test and validate failures. For his own coding agent the tool-calling agent is about 20 lines of Pydantic AI and everything around it is the harness. His supporting data point: LangChain kept the model fixed, changed only the harness, and moved from roughly 30th place into the top 5 on Terminal-Bench.
https://x.com/pauliusztin_/status/2098750979353063495
Someone building a coding agent from scratch reports the most useful thing he has learned so far: the LLM is probably the smallest part of a good agent. The core loop is surprisingly small, reason, act, observe, repeat. What that loop alone doesn't give you is production readiness, which means controlling what context reaches the model and how it gets compressed, which tools it can access, which actions can run versus need approval, where tools execute and how memory persists and how you operate sandboxes and subagents, and how you trace, debug, test and validate failures. For his own coding agent the tool-calling agent is about 20 lines of Pydantic AI and everything around it is the harness. His supporting data point: LangChain kept the model fixed, changed only the harness, and moved from roughly 30th place into the top 5 on Terminal-Bench.
#8
@FZeng16218
https://x.com/FZeng16218/status/2098444619285709124
The most important negative result of the window: self-improving agent harnesses can quietly overfit themselves into worse infrastructure. A paper called Ecdysis tracked what happens when agents automatically edit their harness after failures. The headline numbers are good, average accuracy from 58.67 to 69.56 percent, Qwen3-8B on Airline from 35 to 60 percent, harness training up to 1.84 times faster, and a harness evolved using Qwen3-8B improved Qwen3-32B from 51.67 to 68.33 percent without being evolved again. But the buried result is the one to keep. Researchers manually inspected the harness edits and found that 60 percent of normal self-evolution changes were accommodations for quirks of the current model, which Ecdysis cut to 45.5 percent. Some runs would see 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. Self-improving agents need failure attribution before they start rewriting their own runtime.
https://x.com/FZeng16218/status/2098444619285709124
The most important negative result of the window: self-improving agent harnesses can quietly overfit themselves into worse infrastructure. A paper called Ecdysis tracked what happens when agents automatically edit their harness after failures. The headline numbers are good, average accuracy from 58.67 to 69.56 percent, Qwen3-8B on Airline from 35 to 60 percent, harness training up to 1.84 times faster, and a harness evolved using Qwen3-8B improved Qwen3-32B from 51.67 to 68.33 percent without being evolved again. But the buried result is the one to keep. Researchers manually inspected the harness edits and found that 60 percent of normal self-evolution changes were accommodations for quirks of the current model, which Ecdysis cut to 45.5 percent. Some runs would see 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. Self-improving agents need failure attribution before they start rewriting their own runtime.
#9
@best_privacy_ai
https://x.com/best_privacy_ai/status/2098125609087926431
The best single agent-run write-up of the window, and the value is entirely in how the agent handled a wall. One sentence on an iPhone 16 Pro Max: create a PPTX researching and collecting benchmarks among GPT-6, Fable-5.1, Grok-4.6, GLM-5.3 and DeepSeek-4.1-Flash. It worked for 55 minutes and came back with a 16-slide deck, driven by GLM-5.3, so one of the five models compared wrote the comparison it appears in. The wall: two of the five vendors publish their benchmark tables as images, and DeepSeek does the same with its price table. Nothing in the run could read an image, the fetch tool returns text, none of the 64 tools offered reads pixels, and the phone's Python ships 122 packages with no OCR. It noticed within one fetch, said so in its own words, then went looking for humans who had already typed those numbers out and found them in VentureBeat, an AI release tracker and a Reddit thread quoting the official announcement. Then it did the part that matters: slide 15 records which numbers arrived that way.
https://x.com/best_privacy_ai/status/2098125609087926431
The best single agent-run write-up of the window, and the value is entirely in how the agent handled a wall. One sentence on an iPhone 16 Pro Max: create a PPTX researching and collecting benchmarks among GPT-6, Fable-5.1, Grok-4.6, GLM-5.3 and DeepSeek-4.1-Flash. It worked for 55 minutes and came back with a 16-slide deck, driven by GLM-5.3, so one of the five models compared wrote the comparison it appears in. The wall: two of the five vendors publish their benchmark tables as images, and DeepSeek does the same with its price table. Nothing in the run could read an image, the fetch tool returns text, none of the 64 tools offered reads pixels, and the phone's Python ships 122 packages with no OCR. It noticed within one fetch, said so in its own words, then went looking for humans who had already typed those numbers out and found them in VentureBeat, an AI release tracker and a Reddit thread quoting the official announcement. Then it did the part that matters: slide 15 records which numbers arrived that way.
#10
@mengyer
https://x.com/mengyer/status/2098087957596901761
Outerloop: open autoresearch on your own cluster. His lab develops it and uses it in their own research, which is the credential that matters for this category.
https://x.com/mengyer/status/2098087957596901761
Outerloop: open autoresearch on your own cluster. His lab develops it and uses it in their own research, which is the credential that matters for this category.
#11
@askalphaxiv
https://x.com/askalphaxiv/status/2098064706384568396
OpenResearch now runs the entire autoresearch loop locally. You can serve models from LMStudio, Ollama, oMLX or any OpenAI-compatible endpoint, which means local model, local harness and local app. Their stated premise is that the capability of tools the open-source community uses should match those of the labs.
https://x.com/askalphaxiv/status/2098064706384568396
OpenResearch now runs the entire autoresearch loop locally. You can serve models from LMStudio, Ollama, oMLX or any OpenAI-compatible endpoint, which means local model, local harness and local app. Their stated premise is that the capability of tools the open-source community uses should match those of the labs.
#12
@evanjconrad
https://x.com/evanjconrad/status/2098565916787413268
Givemeanode is now SF Autoresearch, a product from SFC: a scalable, resilient platform for agent-driven machine learning research. Notable as the moment autoresearch stopped being a practice and became something you buy.
https://x.com/evanjconrad/status/2098565916787413268
Givemeanode is now SF Autoresearch, a product from SFC: a scalable, resilient platform for agent-driven machine learning research. Notable as the moment autoresearch stopped being a practice and became something you buy.
#13
@_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, rather than replacing them.
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, rather than replacing them.
#14
@btcinsider__
https://x.com/btcinsider__/status/2098085340091212151
Robin Linus, who discovered BitVM, launched Solving Bitcoin, an autoresearch project to advance the state of the art in Bitcoin protocols, with an open invitation to researchers and the Bitcoin-curious to point their agents at it. The secp256k1 challenge pattern is now being copied deliberately.
https://x.com/btcinsider__/status/2098085340091212151
Robin Linus, who discovered BitVM, launched Solving Bitcoin, an autoresearch project to advance the state of the art in Bitcoin protocols, with an open invitation to researchers and the Bitcoin-curious to point their agents at it. The secp256k1 challenge pattern is now being copied deliberately.
#15
@jt_rose
https://x.com/jt_rose/status/2098088666812039515
The value argument behind the open version, quoting the objection to how Navier-Stokes was solved and revealed: it broke the community fabric that emerged over centuries in science, building on each other's results, giving proper credit, not using a big problem for posturing in anticipation of private benefit. They built Yukon Research around those principles, and the early successes of open collaborative autoresearch are what make them exciting to the academics using the platform, because they show another way is still possible.
https://x.com/jt_rose/status/2098088666812039515
The value argument behind the open version, quoting the objection to how Navier-Stokes was solved and revealed: it broke the community fabric that emerged over centuries in science, building on each other's results, giving proper credit, not using a big problem for posturing in anticipation of private benefit. They built Yukon Research around those principles, and the early successes of open collaborative autoresearch are what make them exciting to the academics using the platform, because they show another way is still possible.
#16
@zhengyaojiang
https://x.com/zhengyaojiang/status/2098570324715430084
A researcher working on autoresearch who was also trained as a traditional researcher names the cost honestly. As people delegate more research and engineering directly to agents, the gap between achieving a goal and understanding how it was achieved will become a growing problem. Autonomous systems are generating tremendous progress so it is clearly a bad idea not to use them, but human researchers are becoming more detached from the ideas being tried and their understanding feels less grounded. The ceiling, which only truly innovative ideas can raise, still seems tied to the understanding of top human experts. His working prediction is that people will increasingly use these tools to accelerate understanding as well as produce results.
https://x.com/zhengyaojiang/status/2098570324715430084
A researcher working on autoresearch who was also trained as a traditional researcher names the cost honestly. As people delegate more research and engineering directly to agents, the gap between achieving a goal and understanding how it was achieved will become a growing problem. Autonomous systems are generating tremendous progress so it is clearly a bad idea not to use them, but human researchers are becoming more detached from the ideas being tried and their understanding feels less grounded. The ceiling, which only truly innovative ideas can raise, still seems tied to the understanding of top human experts. His working prediction is that people will increasingly use these tools to accelerate understanding as well as produce results.
#17
@MikeTamir
https://x.com/MikeTamir/status/2098087659876827148
Nous Research introduced Hermes Agent, a self-improving open-source AI agent with a built-in learning loop, multi-platform gateway integration and autonomous skill creation.
https://x.com/MikeTamir/status/2098087659876827148
Nous Research introduced Hermes Agent, a self-improving open-source AI agent with a built-in learning loop, multi-platform gateway integration and autonomous skill creation.
#18
@moltschool
https://x.com/moltschool/status/2098214997297893627
What the Hermes learning loop actually claims to do: create skills from experience, improve them during use, nudge itself to persist knowledge, and build a deepening model of who you are across sessions. It is the only agent making the built-in learning loop the headline feature rather than a plugin.
https://x.com/moltschool/status/2098214997297893627
What the Hermes learning loop actually claims to do: create skills from experience, improve them during use, nudge itself to persist knowledge, and build a deepening model of who you are across sessions. It is the only agent making the built-in learning loop the headline feature rather than a plugin.
#19
@joerg_peetz
https://x.com/joerg_peetz/status/2098431843640959446
A patch release that is really a demonstration of what agent swarms do to a codebase. Hermes Agent v0.21.1 is on paper a patch: 632 merged pull requests, 5,139 non-merge commits, 4,364 files changed, net minus 167,429 lines of code. In practice it is the output of pointing 110 subagents at the Hermes codebase and letting them make 111,352 tool calls over 15 hours, producing 4,271 commits in a single PR touching 2,655 files and removing more than a third of the source. The structural change that matters is that run_agent.py got split into focused modules, with the agent loop, provider resolution, fallback chains, tool dispatch and session state each getting their own home, so a 14,000-line file stopped being the bottleneck for every change.
https://x.com/joerg_peetz/status/2098431843640959446
A patch release that is really a demonstration of what agent swarms do to a codebase. Hermes Agent v0.21.1 is on paper a patch: 632 merged pull requests, 5,139 non-merge commits, 4,364 files changed, net minus 167,429 lines of code. In practice it is the output of pointing 110 subagents at the Hermes codebase and letting them make 111,352 tool calls over 15 hours, producing 4,271 commits in a single PR touching 2,655 files and removing more than a third of the source. The structural change that matters is that run_agent.py got split into focused modules, with the agent loop, provider resolution, fallback chains, tool dispatch and session state each getting their own home, so a 14,000-line file stopped being the bottleneck for every change.
#20
@stretchcloud
https://x.com/stretchcloud/status/2098181725385900486
The clearest framing of what OpenAI moved. The hard part of building a production agent was never the model call, it was orchestration, context compaction, session recovery and safe tool execution, and OpenAI just moved that entire layer into the Agents API. You hand it a task, connect tools and MCP servers, point at a sandbox, and the Codex harness handles session management, context compaction between turns and multi-agent orchestration. The analogy he keeps reaching for is what AWS Lambda did to server management in 2014: the compute was always there, Lambda made it invisible. What remains differentiated is tool design, AGENTS.md context files, MCP server architecture and how cleanly you model the task. Teams that built custom orchestration over the past two years now have to decide whether to migrate.
https://x.com/stretchcloud/status/2098181725385900486
The clearest framing of what OpenAI moved. The hard part of building a production agent was never the model call, it was orchestration, context compaction, session recovery and safe tool execution, and OpenAI just moved that entire layer into the Agents API. You hand it a task, connect tools and MCP servers, point at a sandbox, and the Codex harness handles session management, context compaction between turns and multi-agent orchestration. The analogy he keeps reaching for is what AWS Lambda did to server management in 2014: the compute was always there, Lambda made it invisible. What remains differentiated is tool design, AGENTS.md context files, MCP server architecture and how cleanly you model the task. Teams that built custom orchestration over the past two years now have to decide whether to migrate.
#21
@matijagrcic
https://x.com/matijagrcic/status/2098185744049135999
The distinction that actually clarifies the choice, from someone who did the research. With the Codex SDK and App Server, Codex already provides the agent loop, tools and context management, but you operate it yourself and handle the surrounding process lifecycle, session persistence and recovery infrastructure. With the Agents API, OpenAI operates the Codex harness and maintains the sessions, your backend calls it directly through the OpenAI SDK without going through the Codex SDK, and you get webhooks, live steering and hosted tracing. Execution is a separate choice: an OpenAI hosted sandbox, or your own environment through codex exec-server. So even for a single agent, switching is mainly a decision about who operates the harness, not whether you need to build an agent loop from scratch.
https://x.com/matijagrcic/status/2098185744049135999
The distinction that actually clarifies the choice, from someone who did the research. With the Codex SDK and App Server, Codex already provides the agent loop, tools and context management, but you operate it yourself and handle the surrounding process lifecycle, session persistence and recovery infrastructure. With the Agents API, OpenAI operates the Codex harness and maintains the sessions, your backend calls it directly through the OpenAI SDK without going through the Codex SDK, and you get webhooks, live steering and hosted tracing. Execution is a separate choice: an OpenAI hosted sandbox, or your own environment through codex exec-server. So even for a single agent, switching is mainly a decision about who operates the harness, not whether you need to build an agent loop from scratch.
#22
@YashChaudhary
https://x.com/YashChaudhary/status/2098424004130357314
The operational details of the Agents API, including the two that will decide adoption for some teams. You POST to /v1/agents/sessions with an OpenAI-Beta agents=v1 header and OpenAI runs the loop: orchestration, durable sessions, context compaction and recovery, optional multi-agent and subagents. Environments are OpenAI-hosted, self-hosted through codex exec-server, or partner sandboxes including Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle Cloud, Runloop and Vercel. No extra Agents API fee, just model tokens plus tools plus hosted containers at standard rates. The constraints: US data residency only, and no zero data retention, which self-hosting does not make you eligible for.
https://x.com/YashChaudhary/status/2098424004130357314
The operational details of the Agents API, including the two that will decide adoption for some teams. You POST to /v1/agents/sessions with an OpenAI-Beta agents=v1 header and OpenAI runs the loop: orchestration, durable sessions, context compaction and recovery, optional multi-agent and subagents. Environments are OpenAI-hosted, self-hosted through codex exec-server, or partner sandboxes including Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle Cloud, Runloop and Vercel. No extra Agents API fee, just model tokens plus tools plus hosted containers at standard rates. The constraints: US data residency only, and no zero data retention, which self-hosting does not make you eligible for.
#23
@sergooforai1
https://x.com/sergooforai1/status/2098303353855848947
The one-line version that names the trade honestly. You used to build the agent loop and patch it after every model drop; now the loop is theirs, production-grade, and you keep the prompt, the MCP servers and where the code runs. This isn't another SDK, it's Codex as a service, and the question posed is direct: build the harness yourself, or hand it to OpenAI.
https://x.com/sergooforai1/status/2098303353855848947
The one-line version that names the trade honestly. You used to build the agent loop and patch it after every model drop; now the loop is theirs, production-grade, and you keep the prompt, the MCP servers and where the code runs. This isn't another SDK, it's Codex as a service, and the question posed is direct: build the harness yourself, or hand it to OpenAI.
#24
@Marwan_3atef
https://x.com/Marwan_3atef/status/2098209000110096804
Vercel shipped a build guide for Agents API apps on Next.js with Queues and Sandbox, and the shape is worth noting. OpenAI owns the agent loop and session state, signed webhooks land in Vercel Queues, each session gets an isolated Sandbox that keeps files across follow-ups, and the whole thing scales to zero instead of babysitting a long-lived VM. Managed harness, durable lifecycle, no always-on worker: the boring stack for long-running coding agents.
https://x.com/Marwan_3atef/status/2098209000110096804
Vercel shipped a build guide for Agents API apps on Next.js with Queues and Sandbox, and the shape is worth noting. OpenAI owns the agent loop and session state, signed webhooks land in Vercel Queues, each session gets an isolated Sandbox that keeps files across follow-ups, and the whole thing scales to zero instead of babysitting a long-lived VM. Managed harness, durable lifecycle, no always-on worker: the boring stack for long-running coding agents.
#25
@Marwan_3atef
https://x.com/Marwan_3atef/status/2098011864823181427
The counter-move, in one sentence each. Cursor Cloud Agents can now run in Vercel Sandbox instead of Cursor's own machines: Cursor still owns the harness and inference loop, you bring the execution layer via self-hosted machines with a Firecracker microVM per request, scale-to-zero workers, durable retries and short-lived user-scoped credentials. It's an enterprise plan, but the pattern is the right one. Keep the agent loop, own where the code actually runs.
https://x.com/Marwan_3atef/status/2098011864823181427
The counter-move, in one sentence each. Cursor Cloud Agents can now run in Vercel Sandbox instead of Cursor's own machines: Cursor still owns the harness and inference loop, you bring the execution layer via self-hosted machines with a Firecracker microVM per request, scale-to-zero workers, durable retries and short-lived user-scoped credentials. It's an enterprise plan, but the pattern is the right one. Keep the agent loop, own where the code actually runs.
#26
@Marwan_3atef
https://x.com/Marwan_3atef/status/2097837581236838425
The fully self-hosted end of the same spectrum. Coder Agents is GA: the agent loop and the execution both stay on infrastructure you control, including air-gapped, and you can pair it with Agent Relay when you want cloud-hosted agents writing into self-hosted workspaces, same operating layer with a different trust boundary. The beta signal he flags is the real story: nearly 70 percent of workloads came through the API rather than the chat UI. Agents as infrastructure, not a sidebar toy.
https://x.com/Marwan_3atef/status/2097837581236838425
The fully self-hosted end of the same spectrum. Coder Agents is GA: the agent loop and the execution both stay on infrastructure you control, including air-gapped, and you can pair it with Agent Relay when you want cloud-hosted agents writing into self-hosted workspaces, same operating layer with a different trust boundary. The beta signal he flags is the real story: nearly 70 percent of workloads came through the API rather than the chat UI. Agents as infrastructure, not a sidebar toy.
#27
@stretchcloud
https://x.com/stretchcloud/status/2098362415905968578
On Cursor Projects, the argument that the coordinator matters more than the subagent count. Every coding agent before this worked the same way: open a session, describe a task, agent executes, session ends. Projects inverts it, with one coordinator thread staying open for the life of a project. The coordinator doesn't write code, it plans, delegates to subagents and brings results back to check. Close your laptop and the project keeps running; point it at a Slack channel for bug reports and it delegates automatically without waiting for a prompt. His read on what matters at scale: not which model writes the code, but the agent that understands the whole project, breaks the work down correctly, and stays current on what's done.
https://x.com/stretchcloud/status/2098362415905968578
On Cursor Projects, the argument that the coordinator matters more than the subagent count. Every coding agent before this worked the same way: open a session, describe a task, agent executes, session ends. Projects inverts it, with one coordinator thread staying open for the life of a project. The coordinator doesn't write code, it plans, delegates to subagents and brings results back to check. Close your laptop and the project keeps running; point it at a Slack channel for bug reports and it delegates automatically without waiting for a prompt. His read on what matters at scale: not which model writes the code, but the agent that understands the whole project, breaks the work down correctly, and stays current on what's done.
#28
@ConsciousRide
https://x.com/ConsciousRide/status/2098633973304004896
The most useful list of the window, because it names the questions a harness has to answer. Most AI agents don't fail because the model picked the 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, how many times should it retry, what counts as completed, what happens when the agent says it's done but the result was never verified. A single LLM call hides all of these; an agent loop exposes them. The line to keep: the model chooses a path through the task, the harness decides what that path is allowed to touch. 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.
https://x.com/ConsciousRide/status/2098633973304004896
The most useful list of the window, because it names the questions a harness has to answer. Most AI agents don't fail because the model picked the 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, how many times should it retry, what counts as completed, what happens when the agent says it's done but the result was never verified. A single LLM call hides all of these; an agent loop exposes them. The line to keep: the model chooses a path through the task, the harness decides what that path is allowed to touch. 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.
#29
@ConsciousRide
https://x.com/ConsciousRide/status/2098405097223176387
A clean distinction between loop engineering and graph engineering that comes down to one variable: how much of the execution path you already know before the agent starts. With a loop, the agent looks at the current state, decides what to do next, acts, observes, updates and goes around again, and the path emerges as it works. That fits research agents, coding agents, debugging agents and general assistants, because you don't know in advance whether the next useful step is searching the repo, reading a file, calling a tool, fixing an error or asking a question. The strength is flexibility and the cost is control: agents repeat actions, chase irrelevant paths, consume too many tokens, or continue long after the useful work is done. A good loop therefore needs explicit state, progress tracking, retries, budgets and failure paths.
https://x.com/ConsciousRide/status/2098405097223176387
A clean distinction between loop engineering and graph engineering that comes down to one variable: how much of the execution path you already know before the agent starts. With a loop, the agent looks at the current state, decides what to do next, acts, observes, updates and goes around again, and the path emerges as it works. That fits research agents, coding agents, debugging agents and general assistants, because you don't know in advance whether the next useful step is searching the repo, reading a file, calling a tool, fixing an error or asking a question. The strength is flexibility and the cost is control: agents repeat actions, chase irrelevant paths, consume too many tokens, or continue long after the useful work is done. A good loop therefore needs explicit state, progress tracking, retries, budgets and failure paths.
#30
@ShaneRobinett
https://x.com/ShaneRobinett/status/2098053686534545676
A practical design for compounding operational memory, aimed at CTOs, and the diagnosis is precise. Most agent demos look impressive in a single session and quietly degrade in production. The model is fine and the tools are fine; what fails is memory, because every run rediscovers the same dead ends, relearns the same repo conventions and asks the same clarifying questions you already answered last Tuesday. When an agent finishes a task, teams keep the output and discard the operational residue: the wrong approach it tried first, the correction that actually worked, the reason that correction worked in this codebase. That residue is exactly what you'd capture in a human postmortem. His prescription is two concurrent loops, separating the work from the learning, without fine-tuning and without a 20,000-token system prompt.
https://x.com/ShaneRobinett/status/2098053686534545676
A practical design for compounding operational memory, aimed at CTOs, and the diagnosis is precise. Most agent demos look impressive in a single session and quietly degrade in production. The model is fine and the tools are fine; what fails is memory, because every run rediscovers the same dead ends, relearns the same repo conventions and asks the same clarifying questions you already answered last Tuesday. When an agent finishes a task, teams keep the output and discard the operational residue: the wrong approach it tried first, the correction that actually worked, the reason that correction worked in this codebase. That residue is exactly what you'd capture in a human postmortem. His prescription is two concurrent loops, separating the work from the learning, without fine-tuning and without a 20,000-token system prompt.
#31
@ShaneRobinett
https://x.com/ShaneRobinett/status/2098053496582910254
The same design stated as a rule you can apply tomorrow. Execution loop: plan, tool calls, observe, finish. Learning loop: diff intent against outcome, extract a durable rule, persist it as a small knowledge artifact rather than another bloated system prompt. The next run loads those artifacts the way a service loads config, scoped, versioned and overwrite-friendly, so bad decisions get corrected once and good patterns survive across coding, review and research. Same model weights, same tool surface, compounding judgment, because you're storing operational memory instead of rediscovering the same failure every sprint. His bar: if the agent can't inherit yesterday's corrections, it's a demo, not infrastructure.
https://x.com/ShaneRobinett/status/2098053496582910254
The same design stated as a rule you can apply tomorrow. Execution loop: plan, tool calls, observe, finish. Learning loop: diff intent against outcome, extract a durable rule, persist it as a small knowledge artifact rather than another bloated system prompt. The next run loads those artifacts the way a service loads config, scoped, versioned and overwrite-friendly, so bad decisions get corrected once and good patterns survive across coding, review and research. Same model weights, same tool surface, compounding judgment, because you're storing operational memory instead of rediscovering the same failure every sprint. His bar: if the agent can't inherit yesterday's corrections, it's a demo, not infrastructure.
#32
@proAlishke
https://x.com/proAlishke/status/2098101706571550763
The most-repeated claim of the window, and its most vivid framing: he spent eight months babysitting a single chat window, prompt, read, fix, prompt again, then stopped supervising the model and started building loops that check their own work, and six weeks later was out-shipping the team he sat on. The line worth keeping regardless of whether the percentages are real: close the agent loop, give the model a way to verify its own output. That's not a prompting gap, that's a loop gap, and it takes one evening to close.
https://x.com/proAlishke/status/2098101706571550763
The most-repeated claim of the window, and its most vivid framing: he spent eight months babysitting a single chat window, prompt, read, fix, prompt again, then stopped supervising the model and started building loops that check their own work, and six weeks later was out-shipping the team he sat on. The line worth keeping regardless of whether the percentages are real: close the agent loop, give the model a way to verify its own output. That's not a prompting gap, that's a loop gap, and it takes one evening to close.
#33
@martynov014
https://x.com/martynov014/status/2098102923658170672
Stanford opened a course this quarter on self-improving AI agents and the instructor names the bottleneck out loud in the first lecture: verification continues to be one of the bottlenecks in this space. The mechanism fits in one line β stop asking the model once, ask it many times, then use a verifier to pick the answer that is actually right. The model itself never changes; the entire gain happens at inference. Generate, verify, select, feed it back, train on what survived. That last arrow is the whole course, because the moment you can reliably tell a good output from a bad one, generations become training data and the model starts improving itself. Which is exactly why verification got a lecture of its own: take the verifier away and you're back to LLM-as-judge, reward models and tools standing in for ground truth, all of it approximate and none of it demoable.
https://x.com/martynov014/status/2098102923658170672
Stanford opened a course this quarter on self-improving AI agents and the instructor names the bottleneck out loud in the first lecture: verification continues to be one of the bottlenecks in this space. The mechanism fits in one line β stop asking the model once, ask it many times, then use a verifier to pick the answer that is actually right. The model itself never changes; the entire gain happens at inference. Generate, verify, select, feed it back, train on what survived. That last arrow is the whole course, because the moment you can reliably tell a good output from a bad one, generations become training data and the model starts improving itself. Which is exactly why verification got a lecture of its own: take the verifier away and you're back to LLM-as-judge, reward models and tools standing in for ground truth, all of it approximate and none of it demoable.
#34
@VextLabs
https://x.com/VextLabs/status/2097858313828659694
The failure mode worth watching in self-improving harnesses, stated as a question nobody has answered: who verifies the harness's own edits? If the harness writes its own tests, it can also lower them. Auto-research needs an audit trail that the research loop itself can't rewrite.
https://x.com/VextLabs/status/2097858313828659694
The failure mode worth watching in self-improving harnesses, stated as a question nobody has answered: who verifies the harness's own edits? If the harness writes its own tests, it can also lower them. Auto-research needs an audit trail that the research loop itself can't rewrite.
#35
@remi7914
https://x.com/remi7914/status/2098521890381869256
The same objection with a concrete consequence. Own the harness, agreed. The part that still collapses is the success signal: if the verifier is the agent said done, the self-improving loop learns theater. What you want is the same minimal kit of context, tools, memory and evals, plus a check that the world actually changed, and a gate before that write counts as a fact.
https://x.com/remi7914/status/2098521890381869256
The same objection with a concrete consequence. Own the harness, agreed. The part that still collapses is the success signal: if the verifier is the agent said done, the self-improving loop learns theater. What you want is the same minimal kit of context, tools, memory and evals, plus a check that the world actually changed, and a gate before that write counts as a fact.
#36
@AfterThe925
https://x.com/AfterThe925/status/2098183912941818245
A concrete thing to do tonight, extracted from a fifty-dollar harness search where the same weights got three times the Terminal-Bench score after three named fixes. Add verify-before-stop as a hard gate in the agent loop: if it announces done without a check command, it isn't done.
https://x.com/AfterThe925/status/2098183912941818245
A concrete thing to do tonight, extracted from a fifty-dollar harness search where the same weights got three times the Terminal-Bench score after three named fixes. Add verify-before-stop as a hard gate in the agent loop: if it announces done without a check command, it isn't done.
#37
@milocodes_
https://x.com/milocodes_/status/2097900622859444499
The failure everyone recognizes, phrased as an open question. You give an agent permission to resolve a small dependency issue and watch it confidently decide the lockfile needs a full rewrite. Sometimes the agentic loop feels like the engineering equivalent of the halting problem: how many tool calls do you let it waste before you kill the process?
https://x.com/milocodes_/status/2097900622859444499
The failure everyone recognizes, phrased as an open question. You give an agent permission to resolve a small dependency issue and watch it confidently decide the lockfile needs a full rewrite. Sometimes the agentic loop feels like the engineering equivalent of the halting problem: how many tool calls do you let it waste before you kill the process?
#38
@nandanpri
https://x.com/nandanpri/status/2098765470211981668
The cheapest possible lesson from the most expensive possible mistake: he burned a whole Claude Code weekly limit once by leaving an overnight agent loop uncapped. He now sets a hard spend ceiling plus a 2am kill cron before any unsupervised run.
https://x.com/nandanpri/status/2098765470211981668
The cheapest possible lesson from the most expensive possible mistake: he burned a whole Claude Code weekly limit once by leaving an overnight agent loop uncapped. He now sets a hard spend ceiling plus a 2am kill cron before any unsupervised run.
#39
@dair_ai
https://x.com/dair_ai/status/2097935359384719537
Meta deployed an autonomous agent that runs the ML iteration cycle across a portfolio of production ads ranking models, and the framing of the bottleneck is the useful part. Modern ads ranking is limited by how many research, implement, train, debug, evaluate and launch cycles engineers can run, rather than by model capacity or training compute. Each cycle takes days to weeks of senior engineer attention per model, so techniques proven on one model spread slowly to the rest. A-MLE splits the cycle into five stages covering hypothesis generation, exploration strategy, experiment execution, result analysis and a shared knowledge substrate, with one agent orchestrating them against a sandboxed execution layer and human checkpoints at every stage boundary. They also ran a controlled cross-LLM study with the agent loop held fixed: the Claude Sonnet, Gemini and GPT families differ in execution reliability and exploration aggressiveness.
https://x.com/dair_ai/status/2097935359384719537
Meta deployed an autonomous agent that runs the ML iteration cycle across a portfolio of production ads ranking models, and the framing of the bottleneck is the useful part. Modern ads ranking is limited by how many research, implement, train, debug, evaluate and launch cycles engineers can run, rather than by model capacity or training compute. Each cycle takes days to weeks of senior engineer attention per model, so techniques proven on one model spread slowly to the rest. A-MLE splits the cycle into five stages covering hypothesis generation, exploration strategy, experiment execution, result analysis and a shared knowledge substrate, with one agent orchestrating them against a sandboxed execution layer and human checkpoints at every stage boundary. They also ran a controlled cross-LLM study with the agent loop held fixed: the Claude Sonnet, Gemini and GPT families differ in execution reliability and exploration aggressiveness.
#40
@HaoZhe65347
https://x.com/HaoZhe65347/status/2098338297848483862
The number that makes autoresearch legible as a filter rather than a generator. Across 535 executable environments, agents explored 152 initial directions, extending promising ideas through independent auto-research loops. Only four mechanisms survived the filtering process.
https://x.com/HaoZhe65347/status/2098338297848483862
The number that makes autoresearch legible as a filter rather than a generator. Across 535 executable environments, agents explored 152 initial directions, extending promising ideas through independent auto-research loops. Only four mechanisms survived the filtering process.
#41
@09j8wu346bg2
https://x.com/09j8wu346bg2/status/2098352254331814115
NVIDIA quietly put an agent called SoL-Pi on GitHub. It scales auto-research loops for agents and improves efficiency for other agents, which makes it one of the few pieces of tooling aimed at the loop itself rather than at what the loop produces.
https://x.com/09j8wu346bg2/status/2098352254331814115
NVIDIA quietly put an agent called SoL-Pi on GitHub. It scales auto-research loops for agents and improves efficiency for other agents, which makes it one of the few pieces of tooling aimed at the loop itself rather than at what the loop produces.
#42
@_wilfredh
https://x.com/_wilfredh/status/2098533703748104227
A small honest autoresearch experiment with a useful caveat. He prompted Sol to make difftastic faster without changing output on the test suite, and to log everything it tried. It found some interesting performance tweaks, although it's too tolerant of complexity.
https://x.com/_wilfredh/status/2098533703748104227
A small honest autoresearch experiment with a useful caveat. He prompted Sol to make difftastic faster without changing output on the test suite, and to log everything it tried. It found some interesting performance tweaks, although it's too tolerant of complexity.
#43
@fmind_dev
https://x.com/fmind_dev/status/2098014587433984031
Sixty-ninth place out of 4,251 teams and a silver medal in Kaggle's AI Agent Security competition, powered entirely by an agent loop. His reason for building it is the honest part: he wanted to enter Kaggle but lacked time, so he built an agent loop to compete for him while he steered.
https://x.com/fmind_dev/status/2098014587433984031
Sixty-ninth place out of 4,251 teams and a silver medal in Kaggle's AI Agent Security competition, powered entirely by an agent loop. His reason for building it is the honest part: he wanted to enter Kaggle but lacked time, so he built an agent loop to compete for him while he steered.
#44
@hu_yifei
https://x.com/hu_yifei/status/2098091053954068657
A one-liner that says a lot about where the limits bind. He used GPT-6 Astra ultra fast mode to run overnight auto-research with goal mode, had to reset his weekly limit twice, and the results are solid.
https://x.com/hu_yifei/status/2098091053954068657
A one-liner that says a lot about where the limits bind. He used GPT-6 Astra ultra fast mode to run overnight auto-research with goal mode, had to reset his weekly limit twice, and the results are solid.
#45
@linlishiac
https://x.com/linlishiac/status/2097853626907521345
The inverse problem, and it's a real one. Outside of massive research sweeps and a few failed autoresearch experiments, he almost never hits the limits on his $200 Codex and Claude plans. So beyond building another useless web app or dashboard, what meaningful work can he actually point all that capacity at?
https://x.com/linlishiac/status/2097853626907521345
The inverse problem, and it's a real one. Outside of massive research sweeps and a few failed autoresearch experiments, he almost never hits the limits on his $200 Codex and Claude plans. So beyond building another useless web app or dashboard, what meaningful work can he actually point all that capacity at?
#46
@0xsamgreen
https://x.com/0xsamgreen/status/2098490400453677452
A warning that will affect a lot of people doing exactly this: his friend's OpenAI business account just got permanently banned for doing auto-research to build a classifier for an electrical engineering problem.
https://x.com/0xsamgreen/status/2098490400453677452
A warning that will affect a lot of people doing exactly this: his friend's OpenAI business account just got permanently banned for doing auto-research to build a classifier for an electrical engineering problem.
#47
@RobertMiller34
https://x.com/RobertMiller34/status/2098480411651268770
A personal research stack that closes the loop: ResearchBot uses alphaXiv and OpenResearch to pull arXiv papers related to his vision model project and run tests against it, combined with a custom AutoResearch framework so it can hypothesize and iterate to get results.
https://x.com/RobertMiller34/status/2098480411651268770
A personal research stack that closes the loop: ResearchBot uses alphaXiv and OpenResearch to pull arXiv papers related to his vision model project and run tests against it, combined with a custom AutoResearch framework so it can hypothesize and iterate to get results.
#48
@siva_sainath91
https://x.com/siva_sainath91/status/2098492936807997932
A reinforcement-learning runner that handles his RL training runs autonomously, steers them in the right direction, and works with him to strategize and evaluate new approaches to maximise the optimal policy. Notably a research loop where the human stays in the strategy seat rather than the execution seat.
https://x.com/siva_sainath91/status/2098492936807997932
A reinforcement-learning runner that handles his RL training runs autonomously, steers them in the right direction, and works with him to strategize and evaluate new approaches to maximise the optimal policy. Notably a research loop where the human stays in the strategy seat rather than the execution seat.
#49
@mrstrijker
https://x.com/mrstrijker/status/2098115877707084044
A non-software autoresearch target worth logging: using it to improve a model for container stowage in ships.
https://x.com/mrstrijker/status/2098115877707084044
A non-software autoresearch target worth logging: using it to improve a model for container stowage in ships.
#50
@mattparlmer
https://x.com/mattparlmer/status/2098515068795469836
A prediction about where this spreads next: the physical side of manufacturing autoresearch is going to be a very big deal, and prototyping volume will go up considerably in all categories.
https://x.com/mattparlmer/status/2098515068795469836
A prediction about where this spreads next: the physical side of manufacturing autoresearch is going to be a very big deal, and prototyping volume will go up considerably in all categories.
#51
@kiranhunter
https://x.com/kiranhunter/status/2097910507655332197
OpenAI launched The Defense Factory, a continuous agent loop to find, validate and patch vulnerabilities, structured as inventory, discover, reproduce in isolated environments, assign owner, verify fix. The framing that matters: agents plus open-weight models can now chain exploits at scale, and defenders still have a head start because they have their own code and frontier models, but the window is closing.
https://x.com/kiranhunter/status/2097910507655332197
OpenAI launched The Defense Factory, a continuous agent loop to find, validate and patch vulnerabilities, structured as inventory, discover, reproduce in isolated environments, assign owner, verify fix. The framing that matters: agents plus open-weight models can now chain exploits at scale, and defenders still have a head start because they have their own code and frontier models, but the window is closing.
#52
@LoongUp
https://x.com/LoongUp/status/2098296744484405388
The sharpest one-line statement of what AI does to the malware detection economy, and it's about a loop. The malware-rebuild-via-agent loop is the actual story: 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.
https://x.com/LoongUp/status/2098296744484405388
The sharpest one-line statement of what AI does to the malware detection economy, and it's about a loop. The malware-rebuild-via-agent loop is the actual story: 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.
#53
@spiroskaye
https://x.com/spiroskaye/status/2098523505524613242
A concrete research-assistant ask that shows where this lands for individuals: an auto-research bot specialised for his master's research area, to assist with the research itself, design methodology and experiment setup.
https://x.com/spiroskaye/status/2098523505524613242
A concrete research-assistant ask that shows where this lands for individuals: an auto-research bot specialised for his master's research area, to assist with the research itself, design methodology and experiment setup.
#54
@KrishWiller
https://x.com/KrishWiller/status/2098168365676396581
A request that names a failure mode directly: build an agent memory mechanism for auto-research and coding scenarios, because Astra has been stuck on his project for two days and he wants to see if SWE-2 can break out of the endless cycle of repeatedly fixing bugs.
https://x.com/KrishWiller/status/2098168365676396581
A request that names a failure mode directly: build an agent memory mechanism for auto-research and coding scenarios, because Astra has been stuck on his project for two days and he wants to see if SWE-2 can break out of the endless cycle of repeatedly fixing bugs.
#55
@praneelmkdir
https://x.com/praneelmkdir/status/2097910699871637853
The shortest full case of the window: he built an entire job application automation agent loop and already has an interview in less than a week.
https://x.com/praneelmkdir/status/2097910699871637853
The shortest full case of the window: he built an entire job application automation agent loop and already has an interview in less than a week.
#56
@grok
https://x.com/grok/status/2098122352710017048
A definition worth having a name for. A gauntlet loop, popularized by Matt Shumer, gives a goal plus a concrete high-quality reference bar. The agent splits the work, a builder creates each piece, a separate critic does a blind comparison to the bar, and it loops fixing gaps until the output beats the standard. The harness is the agentic setup that lets the model use tools, edit and run code, inspect results and spawn sub-agents so the multi-agent loop can actually work.
https://x.com/grok/status/2098122352710017048
A definition worth having a name for. A gauntlet loop, popularized by Matt Shumer, gives a goal plus a concrete high-quality reference bar. The agent splits the work, a builder creates each piece, a separate critic does a blind comparison to the bar, and it loops fixing gaps until the output beats the standard. The harness is the agentic setup that lets the model use tools, edit and run code, inspect results and spawn sub-agents so the multi-agent loop can actually work.
#57
@v4vix
https://x.com/v4vix/status/2098780084601864317
An opinionated call that runs against a lot of the multi-agent architecture diagrams circulating right now: in their deployments, one agent loop with skills beat a fleet of domain subagents.
https://x.com/v4vix/status/2098780084601864317
An opinionated call that runs against a lot of the multi-agent architecture diagrams circulating right now: in their deployments, one agent loop with skills beat a fleet of domain subagents.
#58
@PaulGugAI
https://x.com/PaulGugAI/status/2098163708040274312
Personal-agent scenario testing on an RTX3080 with two 35B A3B models at IQ2 and IQ3, and the finding is that needle-in-haystack tests don't separate them but a heavy-context multi-turn agentic loop does. On the distracting-context detail test both perform admirably and within tolerance of each other. On the personal-assistant core scenario Ornith 1.5 pulls ahead significantly: Nex N2.5 at IQ2 made zero research or tool calls in all three sub-scenarios and produced no structured terminal submission, while Ornith investigated the workspace, cited evidence, created internal drafts and proposals, and submitted grounded results. In one sub-scenario Ornith recognized a live correction, a cancelled dentist appointment and a new review, and proposed moving the vendor call to 16:45.
https://x.com/PaulGugAI/status/2098163708040274312
Personal-agent scenario testing on an RTX3080 with two 35B A3B models at IQ2 and IQ3, and the finding is that needle-in-haystack tests don't separate them but a heavy-context multi-turn agentic loop does. On the distracting-context detail test both perform admirably and within tolerance of each other. On the personal-assistant core scenario Ornith 1.5 pulls ahead significantly: Nex N2.5 at IQ2 made zero research or tool calls in all three sub-scenarios and produced no structured terminal submission, while Ornith investigated the workspace, cited evidence, created internal drafts and proposals, and submitted grounded results. In one sub-scenario Ornith recognized a live correction, a cancelled dentist appointment and a new review, and proposed moving the vendor call to 16:45.
#59
@bressane
https://x.com/bressane/status/2098549029395386637
A concrete cost-routing result inside an agent loop. He moves Astra inside a cheaper loop: Luna at xhigh sends fresh coding contexts to Astra, stops it after implementation, then handles testing itself. The equivalent demo used 7 percent of a weekly Plus quota versus about 50 percent with Astra alone.
https://x.com/bressane/status/2098549029395386637
A concrete cost-routing result inside an agent loop. He moves Astra inside a cheaper loop: Luna at xhigh sends fresh coding contexts to Astra, stops it after implementation, then handles testing itself. The equivalent demo used 7 percent of a weekly Plus quota versus about 50 percent with Astra alone.
#60
@noriagent
https://x.com/noriagent/status/2098532921145688432
A breakdown of model aggregators that matters for anyone running an agent loop through one. First-party DeepSeek scores 90 percent GPQA and 81 percent TAU; DigitalOcean serving the same weights gets 75 and 58. Most hosts cluster five to seven points below first-party on tool calling and four fall off a cliff on knowledge, and for an agent TAU is the score that matters, so a twenty-point swing is not noise. The operational trap is sharper: DeepSeek in thinking mode emits a reasoning_content block, and in an agent loop the model often tool-calls with empty reasoning. Pass that empty reasoning history back and one provider 400s with code 20015 while Baidu, Alibaba and Cloudflare accept it. So the contract isn't per model, it's per provider.
https://x.com/noriagent/status/2098532921145688432
A breakdown of model aggregators that matters for anyone running an agent loop through one. First-party DeepSeek scores 90 percent GPQA and 81 percent TAU; DigitalOcean serving the same weights gets 75 and 58. Most hosts cluster five to seven points below first-party on tool calling and four fall off a cliff on knowledge, and for an agent TAU is the score that matters, so a twenty-point swing is not noise. The operational trap is sharper: DeepSeek in thinking mode emits a reasoning_content block, and in an agent loop the model often tool-calls with empty reasoning. Pass that empty reasoning history back and one provider 400s with code 20015 while Baidu, Alibaba and Cloudflare accept it. So the contract isn't per model, it's per provider.
#61
@TonyJZhou
https://x.com/TonyJZhou/status/2098492832495423829
The pricing distinction that keeps getting collapsed, stated cleanly: price per token is not price per task. An agent loop multiplies token price by attempts until the diff passes CI, so a cheaper model with a lower first-pass rate can cost more per merged PR.
https://x.com/TonyJZhou/status/2098492832495423829
The pricing distinction that keeps getting collapsed, stated cleanly: price per token is not price per task. An agent loop multiplies token price by attempts until the diff passes CI, so a cheaper model with a lower first-pass rate can cost more per merged PR.
#62
@0xhashlol
https://x.com/0xhashlol/status/2098085513236193753
The moat argument, from someone who has actually swapped models. The moat was never raw capability, it's context plumbing: swapping the model in his agent loop is a one-line change now. What actually moves pass rate is repo indexing, tool definitions, and how aggressively you prune context between turns.
https://x.com/0xhashlol/status/2098085513236193753
The moat argument, from someone who has actually swapped models. The moat was never raw capability, it's context plumbing: swapping the model in his agent loop is a one-line change now. What actually moves pass rate is repo indexing, tool definitions, and how aggressively you prune context between turns.
#63
@0xhashlol
https://x.com/0xhashlol/status/2098115673796874675
A small but real ergonomics complaint that names a recurring hack: every agent loop he writes ends up hardcoding some thinking-budget heuristic per task type, so a real reasoning-effort dial from 1 to 100 is overdue compared to prompt-hacking think harder.
https://x.com/0xhashlol/status/2098115673796874675
A small but real ergonomics complaint that names a recurring hack: every agent loop he writes ends up hardcoding some thinking-budget heuristic per task type, so a real reasoning-effort dial from 1 to 100 is overdue compared to prompt-hacking think harder.
#64
@DaveAtTidy
https://x.com/DaveAtTidy/status/2097837885525217445
A production email assistant where the interesting design choice is where the loop is not. Getting email assistance to work safely takes a lot of cleansing, triage rules, then classification, tagging and extraction with one model and no agentic loop, which gives you a canonical markdown form clean of HTML, ads and embedded images. Only then does their internal agent loop read it and draft replies, never send, and no other egress.
https://x.com/DaveAtTidy/status/2097837885525217445
A production email assistant where the interesting design choice is where the loop is not. Getting email assistance to work safely takes a lot of cleansing, triage rules, then classification, tagging and extraction with one model and no agentic loop, which gives you a canonical markdown form clean of HTML, ads and embedded images. Only then does their internal agent loop read it and draft replies, never send, and no other egress.
#65
@Rahatcodes
https://x.com/Rahatcodes/status/2098104635550507035
A short methodological claim that matches what the Super User side found independently: setting up hooks is a better use of time than adding to an insanely large CLAUDE.md and hoping it works, because you can add deterministic behavior at any point in the hook lifecycle in this agentic loop.
https://x.com/Rahatcodes/status/2098104635550507035
A short methodological claim that matches what the Super User side found independently: setting up hooks is a better use of time than adding to an insanely large CLAUDE.md and hoping it works, because you can add deterministic behavior at any point in the hook lifecycle in this agentic loop.
#66
@DailyDoseOfDS_
https://x.com/DailyDoseOfDS_/status/2098705696938410075
A layer-by-layer breakdown of the Claude Code architecture, with the note that the model is just one node inside the loop. The input layer handles session management, permission gating and YAML-based trust tiers before anything reaches the model. The knowledge layer holds the skill registry, context compressor, task graph and cross-session memory store, which is where harness intelligence lives outside the weights. The context compressor is a five-layer cascade that kicks in around 95 percent capacity and runs structured extraction on file paths, code snippets and error histories while pruning redundant tool outputs, so the goal is to keep context usable rather than merely smaller. The execution layer dispatches tools through a typed registry, with a streaming runtime for parallel execution and a prompt cache that reuses stable prefixes at roughly 10 percent of original cost.
https://x.com/DailyDoseOfDS_/status/2098705696938410075
A layer-by-layer breakdown of the Claude Code architecture, with the note that the model is just one node inside the loop. The input layer handles session management, permission gating and YAML-based trust tiers before anything reaches the model. The knowledge layer holds the skill registry, context compressor, task graph and cross-session memory store, which is where harness intelligence lives outside the weights. The context compressor is a five-layer cascade that kicks in around 95 percent capacity and runs structured extraction on file paths, code snippets and error histories while pruning redundant tool outputs, so the goal is to keep context usable rather than merely smaller. The execution layer dispatches tools through a typed registry, with a streaming runtime for parallel execution and a prompt cache that reuses stable prefixes at roughly 10 percent of original cost.
π‘ Eco Products Radar
Eco Products Radar
The secp256k1 quantum-circuit challenge and its leaderboard were the single most-referenced thing of the window, with Eigen Labs naming the verifier-gated process as the mechanism.
The OpenAI Agents API dominated the infrastructure conversation, read consistently as the Codex harness sold as a managed runtime rather than a new model.
Autoresearch platforms multiplied in one window: Outerloop for your own cluster, OpenResearch running fully local, SF Autoresearch as a product, Yukon Research on open-collaboration principles, and Solving Bitcoin copying the challenge pattern.
Hermes Agent appeared both as the only agent leading with a built-in learning loop and as a demonstration of what 110 subagents do to a codebase in fifteen hours.
Sandbox and execution providers were named over and over as the separable half of the stack: Vercel, Cloudflare, E2B, Modal, DigitalOcean, Daytona and Runloop.
DeepSeek V4.1-Flash was the model people discussed in loop terms, specifically its 890 bytes of KV cache per token and what that does to the cost floor of a long-running loop.
Claude Code, Codex and Pi remain the harnesses people actually benchmark against each other, now measured on cost per merged task rather than raw capability.
The secp256k1 quantum-circuit challenge and its leaderboard were the single most-referenced thing of the window, with Eigen Labs naming the verifier-gated process as the mechanism.
The OpenAI Agents API dominated the infrastructure conversation, read consistently as the Codex harness sold as a managed runtime rather than a new model.
Autoresearch platforms multiplied in one window: Outerloop for your own cluster, OpenResearch running fully local, SF Autoresearch as a product, Yukon Research on open-collaboration principles, and Solving Bitcoin copying the challenge pattern.
Hermes Agent appeared both as the only agent leading with a built-in learning loop and as a demonstration of what 110 subagents do to a codebase in fifteen hours.
Sandbox and execution providers were named over and over as the separable half of the stack: Vercel, Cloudflare, E2B, Modal, DigitalOcean, Daytona and Runloop.
DeepSeek V4.1-Flash was the model people discussed in loop terms, specifically its 890 bytes of KV cache per token and what that does to the cost floor of a long-running loop.
Claude Code, Codex and Pi remain the harnesses people actually benchmark against each other, now measured on cost per merged task rather than raw capability.
Comments