Loop Daily: 2026-09-28
Autoresearch has stopped being only about training runs. Today's best loop spent 70 hours optimizing the shape of a command-line interface for agents, and the richest post was a builder who left a hosted agent loop to run their own with one scoped credential per job. The rest of the day is about the economics and safety of long loops: typed decision models taking the yes-or-no calls off the frontier model, refusal retries that now cost money, latency as a billable line, and a growing chorus that loops need an outside oracle and a trained sense of when to stop.
#1
@dzhng
https://x.com/dzhng/status/2103920745206468894
Autoresearch pointed at interface design instead of model weights: GPT-6 Astra ran an autoresearch loop for about 70 hours to tune the cost and performance of a CLI, searching for the optimal input and output shapes for its API calls and commands. The result is a CLI designed 100% for agents, whose outputs, in the author's words, would make no sense to a human. The raw data from the runs is in the repo. It is the clearest sign yet that the agent-facing interface is itself an optimization target, and a loop can find shapes no human designer would pick.
https://x.com/dzhng/status/2103920745206468894
Autoresearch pointed at interface design instead of model weights: GPT-6 Astra ran an autoresearch loop for about 70 hours to tune the cost and performance of a CLI, searching for the optimal input and output shapes for its API calls and commands. The result is a CLI designed 100% for agents, whose outputs, in the author's words, would make no sense to a human. The raw data from the runs is in the repo. It is the clearest sign yet that the agent-facing interface is itself an optimization target, and a loop can find shapes no human designer would pick.
#2
@prince_twets
https://x.com/prince_twets/status/2103845056130293971
A week inside Devin's cloud agent loop produced the most practical post of the day. The loop itself was the best the author had used, but when the frontier-model limit ran out they could not even continue an existing session, and a code-scan feature kept billing with no off switch even after they told the agent not to use it. So they built Shiba, a cloud software engineer that runs inside their own Cloudflare account, with per-task routing and one scoped credential per job: a database token that cannot drop a table, an auth token that cannot rotate anything, and a dedicated agent inbox. The takeaway: take your harness with you, because one vendor, one model and one login is a decision you only get to make once.
https://x.com/prince_twets/status/2103845056130293971
A week inside Devin's cloud agent loop produced the most practical post of the day. The loop itself was the best the author had used, but when the frontier-model limit ran out they could not even continue an existing session, and a code-scan feature kept billing with no off switch even after they told the agent not to use it. So they built Shiba, a cloud software engineer that runs inside their own Cloudflare account, with per-task routing and one scoped credential per job: a database token that cannot drop a table, an auth token that cannot rotate anything, and a dedicated agent inbox. The takeaway: take your harness with you, because one vendor, one model and one login is a decision you only get to make once.
#3
@graykevinb
https://x.com/graykevinb/status/2103991218996666457
A progress report on Green Eggs, a hand-built harness where the agent writes Python scripts that control a pig subagent over RPC. In this run the agent wrote its own orchestration code to do autoresearch. Next up: spawning subagents from Python and comparators that run directly in Python, powered by Jev-like decision models or an LLM. The author is asking how to build an orchestration benchmark, which is exactly the missing piece once agents start writing their own loops.
https://x.com/graykevinb/status/2103991218996666457
A progress report on Green Eggs, a hand-built harness where the agent writes Python scripts that control a pig subagent over RPC. In this run the agent wrote its own orchestration code to do autoresearch. Next up: spawning subagents from Python and comparators that run directly in Python, powered by Jev-like decision models or an LLM. The author is asking how to build an orchestration benchmark, which is exactly the missing piece once agents start writing their own loops.
#4
@stretchcloud
https://x.com/stretchcloud/status/2104021203287728349
A clear read on where the cost bottleneck in coding agents moved: not intelligence, not context length, but the price of every small decision on the way. jevgrep, a research-agent CLI built this week, uses TypeSafe's Jev to decide which files are relevant before the main coding agent reads them, and is reported to cut coding-agent cost by 40% on SWE-bench. The framing is useful: should I read this file, does this citation support the claim, is this refund valid are classification problems wearing an LLM costume.
https://x.com/stretchcloud/status/2104021203287728349
A clear read on where the cost bottleneck in coding agents moved: not intelligence, not context length, but the price of every small decision on the way. jevgrep, a research-agent CLI built this week, uses TypeSafe's Jev to decide which files are relevant before the main coding agent reads them, and is reported to cut coding-agent cost by 40% on SWE-bench. The framing is useful: should I read this file, does this citation support the claim, is this refund valid are classification problems wearing an LLM costume.
#5
@cryptowluha
https://x.com/cryptowluha/status/2103817724187017448
One builder ran Jev across every live agent loop they had and found most frontier-model calls were answering yes-or-no questions. The rebuild splits every operation into generation, decision or hard rule, logs each yes/no as its own event, hands decisions to a typed model that returns probabilities, gates every tool call with a risk check, and keeps the probability spread next to the action it triggered. The LLM keeps generation, the decision model owns judgment, and code owns enforcement.
https://x.com/cryptowluha/status/2103817724187017448
One builder ran Jev across every live agent loop they had and found most frontier-model calls were answering yes-or-no questions. The rebuild splits every operation into generation, decision or hard rule, logs each yes/no as its own event, hands decisions to a typed model that returns probabilities, gates every tool call with a risk check, and keeps the probability spread next to the action it triggered. The LLM keeps generation, the decision model owns judgment, and code owns enforcement.
#6
@Vladic_ETH
https://x.com/Vladic_ETH/status/2104198303919305127
A useful explainer on the week's loudest loop output, the Opus 5.5 videos. The model does not generate video; it writes a program that draws every frame, a browser captures frames and ffmpeg stitches the MP4. The viral case that ran 12 hours overnight used a roughly 9,500-character brief with audio, references, a repo and an instruction to iterate until it stopped looking cheap. Over 280 public clips with source prompts appeared in a week. Its best line: if a 2.5-minute clip holds without mush in the frame, it is not Sora, it is a compile.
https://x.com/Vladic_ETH/status/2104198303919305127
A useful explainer on the week's loudest loop output, the Opus 5.5 videos. The model does not generate video; it writes a program that draws every frame, a browser captures frames and ffmpeg stitches the MP4. The viral case that ran 12 hours overnight used a roughly 9,500-character brief with audio, references, a repo and an instruction to iterate until it stopped looking cheap. Over 280 public clips with source prompts appeared in a week. Its best line: if a 2.5-minute clip holds without mush in the frame, it is not Sora, it is a compile.
#7
@SynScience
https://x.com/SynScience/status/2104231436052271495
OpenScience came out of beta as an open-source scientific agent with autoresearch built in: give it a metric and it hill-climbs through experiments on its own. It bundles a redesigned research IDE, a pay-as-you-go wallet across 30-plus models, one-click OAuth for ChatGPT or Codex subscriptions, 300-plus research skills, 50-plus scientific tools and databases, and NVIDIA BioNeMo, and says it is already used at more than 30 universities and labs.
https://x.com/SynScience/status/2104231436052271495
OpenScience came out of beta as an open-source scientific agent with autoresearch built in: give it a metric and it hill-climbs through experiments on its own. It bundles a redesigned research IDE, a pay-as-you-go wallet across 30-plus models, one-click OAuth for ChatGPT or Codex subscriptions, 300-plus research skills, 50-plus scientific tools and databases, and NVIDIA BioNeMo, and says it is already used at more than 30 universities and labs.
#8
@aasimmalikin
https://x.com/aasimmalikin/status/2104120432295358935
A builder posted the full architecture of Hangul, their own agent, and the loop at its center is deliberately plain: an async loop with no framework, model turn, tool calls, checkpoint, repeat. Around it sit an approval policy that pauses risky tools like send, write and create for a click, seven layers of prompt-injection defense, per-request tool sets wired only to the user's own data, one run per chat so two tabs cannot corrupt a conversation, and a token vault where a proxy swaps in real keys so the model never sees them. Evals and a CI gate cover answer quality, tool selection and injection attacks.
https://x.com/aasimmalikin/status/2104120432295358935
A builder posted the full architecture of Hangul, their own agent, and the loop at its center is deliberately plain: an async loop with no framework, model turn, tool calls, checkpoint, repeat. Around it sit an approval policy that pauses risky tools like send, write and create for a click, seven layers of prompt-injection defense, per-request tool sets wired only to the user's own data, one run per chat so two tabs cannot corrupt a conversation, and a token vault where a proxy swaps in real keys so the model never sees them. Evals and a CI gate cover answer quality, tool selection and injection attacks.
#9
@ivantinkers
https://x.com/ivantinkers/status/2104156262342508894
A founder who built their first product agent a year ago shares the mental model: an agent is a simple loop that keeps calling the model with growing context and a list of tools, with a hard cap on calls if it never finishes. They built the loop themselves in about two days before switching to the Vercel AI SDK, and they name the real cost driver plainly: every decision re-sends an ever-growing prompt, which is why agent costs balloon compared with one-off calls.
https://x.com/ivantinkers/status/2104156262342508894
A founder who built their first product agent a year ago shares the mental model: an agent is a simple loop that keeps calling the model with growing context and a list of tools, with a hard cap on calls if it never finishes. They built the loop themselves in about two days before switching to the Vercel AI SDK, and they name the real cost driver plainly: every decision re-sends an ever-growing prompt, which is why agent costs balloon compared with one-off calls.
#10
@kcosr
https://x.com/kcosr/status/2103833546087395784
A practical infrastructure pattern for long agent loops: keep the agent loop on a small always-on box like a personal NUC and connect it to remote environments over SSH, but split tool execution from loop execution, as Codex's exec server does. Then an executor can spin up a high-powered machine on demand only when a heavy build or test needs it.
https://x.com/kcosr/status/2103833546087395784
A practical infrastructure pattern for long agent loops: keep the agent loop on a small always-on box like a personal NUC and connect it to remote environments over SSH, but split tool execution from loop execution, as Codex's exec server does. Then an executor can spin up a high-powered machine on demand only when a heavy build or test needs it.
#11
@theayubinator
https://x.com/theayubinator/status/2103909879044014114
A skeptic makes the sharpest case against auto-research today: agents behave like overeager interns who chase every new question, rabbit-hole endlessly and draw dramatic conclusions from contrived setups. The analogy is neural: movement needs inhibitory neurons as much as excitatory ones, and today's agents only have the excitatory population because they are optimized to complete tasks. It names what a research loop is missing, a trained sense of when to stop.
https://x.com/theayubinator/status/2103909879044014114
A skeptic makes the sharpest case against auto-research today: agents behave like overeager interns who chase every new question, rabbit-hole endlessly and draw dramatic conclusions from contrived setups. The analogy is neural: movement needs inhibitory neurons as much as excitatory ones, and today's agents only have the excitatory population because they are optimized to complete tasks. It names what a research loop is missing, a trained sense of when to stop.
#12
@jus_eng_njainam
https://x.com/jus_eng_njainam/status/2103754720884248752
A one-paragraph insight on verification in loops: tests written by the same agent that wrote the code assert what the code does, not what it should do, which is why 100% coverage still breaks production. The fix is not fewer tests but tests the agent did not write, because they are the only oracle an agent loop has.
https://x.com/jus_eng_njainam/status/2103754720884248752
A one-paragraph insight on verification in loops: tests written by the same agent that wrote the code assert what the code does, not what it should do, which is why 100% coverage still breaks production. The fix is not fewer tests but tests the agent did not write, because they are the only oracle an agent loop has.
#13
@elledynelabs
https://x.com/elledynelabs/status/2103851856627990553
On loops that review their own PRs: the review step ends up arguing with its own output. The watchdog has to be able to cut power to the whole loop, not just retry one attempt, otherwise non-determinism erases the difference between a CI loop and an agent loop.
https://x.com/elledynelabs/status/2103851856627990553
On loops that review their own PRs: the review step ends up arguing with its own output. The watchdog has to be able to cut power to the whole loop, not just retry one attempt, otherwise non-determinism erases the difference between a CI loop and an agent loop.
#14
@Pakgowithai
https://x.com/Pakgowithai/status/2104049090984296948
A cost trap for anyone running agent loops on the Claude API this week: Anthropic charges again when safeguards block a request before Claude replies, in three categories, biology, distillation attacks and frontier LLM development. If a loop retries the same blocked prompt, you pay for every attempt. The advice: log stop_reason and category, fall back to another model, and never hammer the same one.
https://x.com/Pakgowithai/status/2104049090984296948
A cost trap for anyone running agent loops on the Claude API this week: Anthropic charges again when safeguards block a request before Claude replies, in three categories, biology, distillation attacks and frontier LLM development. If a loop retries the same blocked prompt, you pay for every attempt. The advice: log stop_reason and category, fall back to another model, and never hammer the same one.
#15
@ares_mheinke
https://x.com/ares_mheinke/status/2104108263214358794
A latency-first reading of a new free model: on the same Vercel table, Pixel Canary averaged about 1,016 seconds per task versus about 252 for GPT-6 Astra on high, both at 90%. Four times the wall clock inside an agent loop compounds on every call, so this user would rather pay for the faster 90%. Another commenter makes the same point about pricing: if an ultrafast tier gets its own price, latency officially becomes a line item.
https://x.com/ares_mheinke/status/2104108263214358794
A latency-first reading of a new free model: on the same Vercel table, Pixel Canary averaged about 1,016 seconds per task versus about 252 for GPT-6 Astra on high, both at 90%. Four times the wall clock inside an agent loop compounds on every call, so this user would rather pay for the faster 90%. Another commenter makes the same point about pricing: if an ultrafast tier gets its own price, latency officially becomes a line item.
#16
@vishalmisra
https://x.com/vishalmisra/status/2103806214865834039
A crisp statement of the limit every loop builder works around: current LLMs are reactive. With no prompt, tool result, scheduler or agent loop, there is no computation. Humans generate their own questions, revisit memories and pursue thoughts unprompted, and wrapping an LLM in a loop makes it look proactive but it is still a loop.
https://x.com/vishalmisra/status/2103806214865834039
A crisp statement of the limit every loop builder works around: current LLMs are reactive. With no prompt, tool result, scheduler or agent loop, there is no computation. Humans generate their own questions, revisit memories and pursue thoughts unprompted, and wrapping an LLM in a loop makes it look proactive but it is still a loop.
#17
@Shadowfetch
https://x.com/Shadowfetch/status/2103949993476514052
A small but real hosting split for always-on agents: a VPS with Tailscale is great for the agent loop itself, but a Mac mini still wins for Xcode, code signing and simulator work, so run the general agent host and the native build machine separately.
https://x.com/Shadowfetch/status/2103949993476514052
A small but real hosting split for always-on agents: a VPS with Tailscale is great for the agent loop itself, but a Mac mini still wins for Xcode, code signing and simulator work, so run the general agent host and the native build machine separately.
#18
@iamnotkookie
https://x.com/iamnotkookie/status/2103968443590381916
A snapshot of a mixed stack before OpenAI's DevDay: Opus 5.5 for the hard code, Grok Bot for overnight digests and the agent loop, Grok 4.7 in Build for the other 90%. If OpenAI's rumored always-on agent is real, the debate is no longer about models but about whether to rip out a week of wiring for a new bot, a switching cost that did not exist a year ago.
https://x.com/iamnotkookie/status/2103968443590381916
A snapshot of a mixed stack before OpenAI's DevDay: Opus 5.5 for the hard code, Grok Bot for overnight digests and the agent loop, Grok 4.7 in Build for the other 90%. If OpenAI's rumored always-on agent is real, the debate is no longer about models but about whether to rip out a week of wiring for a new bot, a switching cost that did not exist a year ago.
π‘ Eco Products Radar
Eco Products Radar
Claude Code (9 mentions): Most common host for loops and the harness people compare against
Grok / Grok Bot (6 mentions): Runs overnight digests and loops in mixed stacks
Codex (5 mentions): Its exec server is cited as the model for splitting tools from the loop
GPT-6 Astra (5 mentions): The model that ran the 70-hour autoresearch loop and the latency baseline
Jev (4 mentions): Typed decision model taking bounded yes-or-no calls out of the loop
Opus 5.5 (4 mentions): The engine behind the overnight video loops
Claude Code (9 mentions): Most common host for loops and the harness people compare against
Grok / Grok Bot (6 mentions): Runs overnight digests and loops in mixed stacks
Codex (5 mentions): Its exec server is cited as the model for splitting tools from the loop
GPT-6 Astra (5 mentions): The model that ran the 70-hour autoresearch loop and the latency baseline
Jev (4 mentions): Typed decision model taking bounded yes-or-no calls out of the loop
Opus 5.5 (4 mentions): The engine behind the overnight video loops
Comments