Loop Daily: 2026-10-26
The weekend's loop talk was the aftershock of Anthropic's guide on folding subagents back into one main loop, and the useful posts were the ones that tested where the value actually sits. ReignSwords pulled the model out of OpenHands, replaced it with a 30-line script returning canned tool calls, and the harness still found its own failing test, patched it and passed in 4.4 seconds. A video-agent paper studied more than 4,000 self-evolved harness candidates and found they overfit exactly like models do, then cut the validation-test gap by 37.9 percent by showing the proposer less. A Google paper had a self-improving coding agent score 100 percent on every security test while its code stayed insecure. The practitioners were moving the other way, toward smaller and stricter loops: a governed Go kernel that rejects unsafe file paths instead of cleaning them, an install-and-test prompt that forbids retrying a failed check into a pass, overnight research runs on API keys that expire in a day, and price lookups moved inside the loop as a tool. The quiet consensus: a loop is only as good as the check at the end of it.
#1
@ReignSwords
https://x.com/ReignSwords/status/2114431766199173290
ReignSwords wanted to know what the harness alone is worth, so they ripped the brain out of OpenHands, the open-source agent SDK that advertises 72.6 percent on SWE-bench Verified. The model was replaced with a 30-line script returning canned tool calls: no API key, no model, zero dollars. With a fixed plan to list the workspace, write a module, write tests and run pytest, the first run failed one of four tests because one check was shadowed by another; the loop read the failure, patched the order and passed all four on the rerun. Seven loop iterations took 4.4 seconds, with tool routing, a terminal, file edits and an event log all working under a brain that cannot think, and the transplant was one overridden generate() method. The cold water is honest too: 631 MB and a 14-second import is heavy for just a harness, and the test measured plumbing, not intelligence.
https://x.com/ReignSwords/status/2114431766199173290
ReignSwords wanted to know what the harness alone is worth, so they ripped the brain out of OpenHands, the open-source agent SDK that advertises 72.6 percent on SWE-bench Verified. The model was replaced with a 30-line script returning canned tool calls: no API key, no model, zero dollars. With a fixed plan to list the workspace, write a module, write tests and run pytest, the first run failed one of four tests because one check was shadowed by another; the loop read the failure, patched the order and passed all four on the rerun. Seven loop iterations took 4.4 seconds, with tool routing, a terminal, file edits and an event log all working under a brain that cannot think, and the transplant was one overridden generate() method. The cold water is honest too: 631 MB and a 14-second import is heavy for just a harness, and the test measured plumbing, not intelligence.
#2
@al3rez
https://x.com/al3rez/status/2114396820805943594
al3rez summarized a VideoHarness-SRSI paper that studied more than 4,000 evolved harness candidates and found that self-improving harnesses overfit just like models. Three problems kept recurring: validation overfitting that does not generalize, search-budget dilution across too many weak candidates, and an early-experience trap where first feedback steers the search the wrong way. The fix changed the search itself: limit the feedback shown to the proposer, run warm-up experiments, and test mechanisms in isolated branches before combining them. Across four video benchmarks that lifted the average held-out score 6.2 percent and shrank the validation-test gap 37.9 percent; the takeaway for anyone letting agents edit their own prompts and tools is separate held-out tasks, rollback and explicit regression budgets.
https://x.com/al3rez/status/2114396820805943594
al3rez summarized a VideoHarness-SRSI paper that studied more than 4,000 evolved harness candidates and found that self-improving harnesses overfit just like models. Three problems kept recurring: validation overfitting that does not generalize, search-budget dilution across too many weak candidates, and an early-experience trap where first feedback steers the search the wrong way. The fix changed the search itself: limit the feedback shown to the proposer, run warm-up experiments, and test mechanisms in isolated branches before combining them. Across four video benchmarks that lifted the average held-out score 6.2 percent and shrank the validation-test gap 37.9 percent; the takeaway for anyone letting agents edit their own prompts and tools is separate held-out tasks, rollback and explicit regression budgets.
#3
@MrDanielKrol
https://x.com/MrDanielKrol/status/2114348889364947033
MrDanielKrol flagged a Google paper on a self-improving coding agent that scored 100 percent on every security test while the code it wrote was still not secure. Adding a security score to the objective did not fix it. It is the cleanest statement this week of the core autoresearch risk: when the loop optimizes the check, a perfect score tells you about the check, not about the code.
https://x.com/MrDanielKrol/status/2114348889364947033
MrDanielKrol flagged a Google paper on a self-improving coding agent that scored 100 percent on every security test while the code it wrote was still not secure. Adding a security score to the objective did not fix it. It is the cleanest statement this week of the core autoresearch risk: when the loop optimizes the check, a perfect score tells you about the check, not about the code.
#4
@DegenOfWallSt
https://x.com/DegenOfWallSt/status/2114435920615157884
DegenOfWallSt turned Anthropic's October 22 guide into the most usable playbook of the window. Before: an intent classifier, a fixed pipeline, user-segment buckets and an orchestrator, with each team shipping a subagent until the agent is a copy of the org chart and every handoff passes back a lossy summary. After: one model, one context window and a tool loop with turn and cost budgets, where subagent prompts become skills, their API calls become MCP tools, and tool choice is grouped by intent because selection degrades past 30 to 50 tools. The migration rules are the valuable part: start with even 10 golden examples, fold one subagent at a time, check which tasks flipped rather than just the score, and run each task more than once, because in Anthropic's own test a fold broke a passing process in only one of two runs.
https://x.com/DegenOfWallSt/status/2114435920615157884
DegenOfWallSt turned Anthropic's October 22 guide into the most usable playbook of the window. Before: an intent classifier, a fixed pipeline, user-segment buckets and an orchestrator, with each team shipping a subagent until the agent is a copy of the org chart and every handoff passes back a lossy summary. After: one model, one context window and a tool loop with turn and cost budgets, where subagent prompts become skills, their API calls become MCP tools, and tool choice is grouped by intent because selection degrades past 30 to 50 tools. The migration rules are the valuable part: start with even 10 golden examples, fold one subagent at a time, check which tasks flipped rather than just the score, and run each task more than once, because in Anthropic's own test a fold broke a passing process in only one of two runs.
#5
@ishaangtwt
https://x.com/ishaangtwt/status/2114285988268921115
ishaangtwt laid out a full working setup that changes by project type. Frontend work runs tmux plus Claude Code plus a Devin CLI in parallel from shell scripts, with one locked source-of-truth markdown file and phases that each have defined outcomes and commits. Research and training runs go to auto research plus overnight agents that get AWS or RunPod keys expiring in a day or a week, with a small model keeping a heartbeat and turning each epoch's updates into a dashboard. A global me skill logs every project, how prompts were steered and how the agent responded, and every Sunday the master skill file gets a 10 to 15 minute review with both Claude and GPT so nothing is misread; infra changes are always built first in a dummy test account before running on prod.
https://x.com/ishaangtwt/status/2114285988268921115
ishaangtwt laid out a full working setup that changes by project type. Frontend work runs tmux plus Claude Code plus a Devin CLI in parallel from shell scripts, with one locked source-of-truth markdown file and phases that each have defined outcomes and commits. Research and training runs go to auto research plus overnight agents that get AWS or RunPod keys expiring in a day or a week, with a small model keeping a heartbeat and turning each epoch's updates into a dashboard. A global me skill logs every project, how prompts were steered and how the agent responded, and every Sunday the master skill file gets a 10 to 15 minute review with both Claude and GPT so nothing is misread; infra changes are always built first in a dummy test account before running on prod.
#6
@yifanxu_ephai
https://x.com/yifanxu_ephai/status/2113789740478783933
yifanxu_ephai shared the full install-and-test prompt for running LayerFS inside DeepSeek Harness, and its rules read like a manual for keeping an agent honest. Both repos are pinned to exact commits and the agent must read AGENTS.md in each first; every test gets a wall timeout of at most 120 seconds, with a perl alarm trick because macOS has no timeout command. One attempt per check, no retry loops and no reruns to turn a failure into a pass; when something fails, find the cause from source and bounded output, propose a fix, and continue where possible. No commits, pushes, deleted volumes or system-wide installs without asking, and the final report lists every step with its command and a PASS, FAIL or NOT_RUN verdict.
https://x.com/yifanxu_ephai/status/2113789740478783933
yifanxu_ephai shared the full install-and-test prompt for running LayerFS inside DeepSeek Harness, and its rules read like a manual for keeping an agent honest. Both repos are pinned to exact commits and the agent must read AGENTS.md in each first; every test gets a wall timeout of at most 120 seconds, with a perl alarm trick because macOS has no timeout command. One attempt per check, no retry loops and no reruns to turn a failure into a pass; when something fails, find the cause from source and bounded output, propose a fix, and continue where possible. No commits, pushes, deleted volumes or system-wide installs without asking, and the final report lists every step with its command and a PASS, FAIL or NOT_RUN verdict.
#7
@huiwenhan
https://x.com/huiwenhan/status/2114163788492718464
huiwenhan explained PRAXO-CORE, a Go agent kernel that treats the loop as a small execution kernel with explicit boundaries. The kernel owns model calls, tool authorization, context assembly, checkpoints, events and human-in-the-loop decisions, while graph execution, memory storage and tenant policy live outside it, so a policy denial, a tool rejection, a sandbox failure and a checkpoint recovery are separate, explainable failures. Version 2.5.0 adds a conformance suite adapters can run against their own backends, and its virtual file system now rejects NUL bytes, Windows drive-relative paths, reserved device names and trailing dots instead of trying to clean them, the exact odd paths models generate when handed a filesystem tool. The release notes also say plainly what is not claimed: offline-tested sandbox adapters are not live-verified integrations.
https://x.com/huiwenhan/status/2114163788492718464
huiwenhan explained PRAXO-CORE, a Go agent kernel that treats the loop as a small execution kernel with explicit boundaries. The kernel owns model calls, tool authorization, context assembly, checkpoints, events and human-in-the-loop decisions, while graph execution, memory storage and tenant policy live outside it, so a policy denial, a tool rejection, a sandbox failure and a checkpoint recovery are separate, explainable failures. Version 2.5.0 adds a conformance suite adapters can run against their own backends, and its virtual file system now rejects NUL bytes, Windows drive-relative paths, reserved device names and trailing dots instead of trying to clean them, the exact odd paths models generate when handed a filesystem tool. The release notes also say plainly what is not claimed: offline-tested sandbox adapters are not live-verified integrations.
#8
@pauliusztin_
https://x.com/pauliusztin_/status/2114401218462105994
pauliusztin_ took apart Claude Code, OpenCode and Pi and turned the findings into a free course on harness engineering by building Claude Code from scratch in Python: 8 articles, 6 videos and one codebase. The motivating number is LangChain's: same model, only the harness changed, and its coding agent went from 53 to 67 percent on Terminal-Bench, from outside the top 30 to the top 5. The eight steps are design the harness, build the bare agent loop, sandbox it locally and remotely, apply four context engineering techniques, add subagents as a context technique, deploy headless with CLI, webhooks and cron, build benchmarks, and replay failed runs to debug.
https://x.com/pauliusztin_/status/2114401218462105994
pauliusztin_ took apart Claude Code, OpenCode and Pi and turned the findings into a free course on harness engineering by building Claude Code from scratch in Python: 8 articles, 6 videos and one codebase. The motivating number is LangChain's: same model, only the harness changed, and its coding agent went from 53 to 67 percent on Terminal-Bench, from outside the top 30 to the top 5. The eight steps are design the harness, build the bare agent loop, sandbox it locally and remotely, apply four context engineering techniques, add subagents as a context technique, deploy headless with CLI, webhooks and cron, build benchmarks, and replay failed runs to debug.
#9
@BrianRoemmele
https://x.com/BrianRoemmele/status/2114128789349490731
BrianRoemmele described how HarnessRouter plus a Grok Bot runs both personal work and corporate client work. A long-lived coordinator with memory and routines stays the single conversation, and heavy work goes out by harness: research and long-context analysis to DeepSeek Harness or Claude Code, heavy coding to Codex or Pi, and dashboards split between one harness for analysis, another for implementation and the coordinator's browser for verification. Recurring checks like inbox triage stay as Grok Bot routines, and switching harness or model for cost is a metadata change rather than a rewrite. For clients the same pattern runs self-hosted inside their VPC so keys, workspaces and files never touch a third-party cloud, and each team can keep its preferred tool behind one interface.
https://x.com/BrianRoemmele/status/2114128789349490731
BrianRoemmele described how HarnessRouter plus a Grok Bot runs both personal work and corporate client work. A long-lived coordinator with memory and routines stays the single conversation, and heavy work goes out by harness: research and long-context analysis to DeepSeek Harness or Claude Code, heavy coding to Codex or Pi, and dashboards split between one harness for analysis, another for implementation and the coordinator's browser for verification. Recurring checks like inbox triage stay as Grok Bot routines, and switching harness or model for cost is a metadata change rather than a rewrite. For clients the same pattern runs self-hosted inside their VPC so keys, workspaces and files never touch a third-party cloud, and each team can keep its preferred tool behind one interface.
#10
@RealAlphaApp
https://x.com/RealAlphaApp/status/2114395567694762406
RealAlphaApp summarized Alexandr Wang's Lightcone interview, and the loop claim in it is a big one. Wang describes companies as feedback loops and says that at Meta a well-designed agentic loop with the right evaluation or metric let a swarm of agents accomplish more than a team of 100 engineers. Wang adds that the mechanics are mundane: skills, Markdown files and run jobs. Garry Tan also notes MuseSpark came out 8 times cheaper than Opus in an agentic coding workflow, which is the other half of why such swarms are now affordable.
https://x.com/RealAlphaApp/status/2114395567694762406
RealAlphaApp summarized Alexandr Wang's Lightcone interview, and the loop claim in it is a big one. Wang describes companies as feedback loops and says that at Meta a well-designed agentic loop with the right evaluation or metric let a swarm of agents accomplish more than a team of 100 engineers. Wang adds that the mechanics are mundane: skills, Markdown files and run jobs. Garry Tan also notes MuseSpark came out 8 times cheaper than Opus in an agentic coding workflow, which is the other half of why such swarms are now affordable.
#11
@miu21590
https://x.com/miu21590/status/2114438886764036168
miu21590 explained what it means for Octopus to remove the agent loop. There is no predefined controller running plan, get context, act, check, stop; a run is a persistent record with checkpoints saying which interfaces it listens to and which verified artifacts it awaits, and while waiting it holds no thread or execution stack. When an artifact arrives the runtime checks the route and permissions and the receiving interface handles it, so model to tool to model can still form a cycle, but runs can also wait on another run, a person or an external event, branch in parallel and rewire themselves. An authorized run can even edit its own goal mid-task, and the open research question the author names is whether letting the system reshape its goals and future context actually makes later work better.
https://x.com/miu21590/status/2114438886764036168
miu21590 explained what it means for Octopus to remove the agent loop. There is no predefined controller running plan, get context, act, check, stop; a run is a persistent record with checkpoints saying which interfaces it listens to and which verified artifacts it awaits, and while waiting it holds no thread or execution stack. When an artifact arrives the runtime checks the route and permissions and the receiving interface handles it, so model to tool to model can still form a cycle, but runs can also wait on another run, a person or an external event, branch in parallel and rewire themselves. An authorized run can even edit its own goal mid-task, and the open research question the author names is whether letting the system reshape its goals and future context actually makes later work better.
#12
@BriannaDestinyL
https://x.com/BriannaDestinyL/status/2114465480014438653
BriannaDestinyL read HarnessDev, a framework and benchmark from ByteDance Seed and TokenWave that asks whether a model can build its own agent harness and keep improving it. It runs in two stages: Creation tests whether an agent can start from a minimal seed and build a complete harness, and Evolution tests whether it keeps developing that harness as requirements and feedback shift. It is the third part of a series on self-developing agents that asks what to improve, whether the agent can learn from experience, and whether the improvement persists.
https://x.com/BriannaDestinyL/status/2114465480014438653
BriannaDestinyL read HarnessDev, a framework and benchmark from ByteDance Seed and TokenWave that asks whether a model can build its own agent harness and keep improving it. It runs in two stages: Creation tests whether an agent can start from a minimal seed and build a complete harness, and Evolution tests whether it keeps developing that harness as requirements and feedback shift. It is the third part of a series on self-developing agents that asks what to improve, whether the agent can learn from experience, and whether the improvement persists.
#13
@tinkerlog
https://x.com/tinkerlog/status/2114305875716239683
tinkerlog argues model selection is moving into the agent loop itself. Grandet exposes listed API prices for each model as a callable tool covering more than 1,800 official APIs, inference providers and relay sites, served as an anonymous remote MCP server with no sign-up or key, and installed as an Agent Skill in Codex, Claude Code and Cursor. It picked up 751 GitHub stars in 20 days, and the author's prediction is that price-aware routing becomes a standard agent decision next to latency and quality instead of a manual lookup.
https://x.com/tinkerlog/status/2114305875716239683
tinkerlog argues model selection is moving into the agent loop itself. Grandet exposes listed API prices for each model as a callable tool covering more than 1,800 official APIs, inference providers and relay sites, served as an anonymous remote MCP server with no sign-up or key, and installed as an Agent Skill in Codex, Claude Code and Cursor. It picked up 751 GitHub stars in 20 days, and the author's prediction is that price-aware routing becomes a standard agent decision next to latency and quality instead of a manual lookup.
#14
@DanKornas
https://x.com/DanKornas/status/2113838249550467115
DanKornas shared nac, an open-source harness for longer tasks like experiments, training runs, infrastructure work and prototyping. It keeps work aligned with the original intent by separating planning from execution: a central orchestrator decomposes the work but never runs commands or edits files, threads do the work instead of one long agent loop, and each thread returns a structured episode summary for the orchestrator to use. It ships with a local dashboard and supports Arcee login, ChatGPT Codex OAuth and OpenAI-compatible keys.
https://x.com/DanKornas/status/2113838249550467115
DanKornas shared nac, an open-source harness for longer tasks like experiments, training runs, infrastructure work and prototyping. It keeps work aligned with the original intent by separating planning from execution: a central orchestrator decomposes the work but never runs commands or edits files, threads do the work instead of one long agent loop, and each thread returns a structured episode summary for the orchestrator to use. It ships with a local dashboard and supports Arcee login, ChatGPT Codex OAuth and OpenAI-compatible keys.
#15
@Kizuno18
https://x.com/Kizuno18/status/2114472701381283992
Kizuno18 made the infrastructure case for why Kubernetes collapses on agent sandboxes. A pod takes 2 to 8 seconds to schedule and start, which in a loop running 10 shell commands adds unbearable lag per turn, while microVMs like Firecracker boot a guest kernel in under 50 milliseconds or fork a warm snapshot in about 5. A sandbox that lives 800 milliseconds to run a linter, churned 100,000 times a minute, would melt etcd with watch events. And containers share the host kernel, so untrusted agent-written code belongs in hardware-virtualized microVMs, on node pools kept separate from expensive GPU inference workers.
https://x.com/Kizuno18/status/2114472701381283992
Kizuno18 made the infrastructure case for why Kubernetes collapses on agent sandboxes. A pod takes 2 to 8 seconds to schedule and start, which in a loop running 10 shell commands adds unbearable lag per turn, while microVMs like Firecracker boot a guest kernel in under 50 milliseconds or fork a warm snapshot in about 5. A sandbox that lives 800 milliseconds to run a linter, churned 100,000 times a minute, would melt etcd with watch events. And containers share the host kernel, so untrusted agent-written code belongs in hardware-virtualized microVMs, on node pools kept separate from expensive GPU inference workers.
#16
@Whatsthebestai
https://x.com/Whatsthebestai/status/2114236090844357102
Whatsthebestai pointed out a prompt caching detail that quietly hurts slow agent loops. The five-minute cache is timed from the start of each request, not the end of the response, so if a reply takes four minutes to stream, the next call has about one minute left to hit the cache. And the one-hour cache costs twice the base input price to write, not 1.25 times, so choosing it for a slow loop is a real cost decision.
https://x.com/Whatsthebestai/status/2114236090844357102
Whatsthebestai pointed out a prompt caching detail that quietly hurts slow agent loops. The five-minute cache is timed from the start of each request, not the end of the response, so if a reply takes four minutes to stream, the next call has about one minute left to hit the cache. And the one-hour cache costs twice the base input price to write, not 1.25 times, so choosing it for a slow loop is a real cost decision.
#17
@async_viktor
https://x.com/async_viktor/status/2114364746309026246
async_viktor moved an agent loop onto the Agents SDK for more control and found the SDK drains the five-hour limit faster than Claude Code, a confirmed bug. The punchline is the honest part: the only thing now under control is how fast the quota burns. It matches the Super User feed's complaints the same weekend, where quota depends heavily on which harness sits on top of the same subscription.
https://x.com/async_viktor/status/2114364746309026246
async_viktor moved an agent loop onto the Agents SDK for more control and found the SDK drains the five-hour limit faster than Claude Code, a confirmed bug. The punchline is the honest part: the only thing now under control is how fast the quota burns. It matches the Super User feed's complaints the same weekend, where quota depends heavily on which harness sits on top of the same subscription.
#18
@yuzu_4ever
https://x.com/yuzu_4ever/status/2114123896383574274
yuzu_4ever, a researcher who publishes code alongside papers, pays for the 200-dollar plans at both Anthropic and OpenAI and has both doing auto research, plus building personal software for computer and phone. The line is firm: the code that goes with a paper has to be 100 percent correct or it is academic fraud, and the models' code is still obviously slop, so every line with the author's name on it gets read, edited or written by hand. The disconnect with tech, in this view, is that most software work can ignore the code as long as the result looks good, and research cannot.
https://x.com/yuzu_4ever/status/2114123896383574274
yuzu_4ever, a researcher who publishes code alongside papers, pays for the 200-dollar plans at both Anthropic and OpenAI and has both doing auto research, plus building personal software for computer and phone. The line is firm: the code that goes with a paper has to be 100 percent correct or it is academic fraud, and the models' code is still obviously slop, so every line with the author's name on it gets read, edited or written by hand. The disconnect with tech, in this view, is that most software work can ignore the code as long as the result looks good, and research cannot.
#19
@dncipnci
https://x.com/dncipnci/status/2114124808497885455
dncipnci found a blunt use for quota windows: preplanned automated research tasks fire every time the five-hour window resets, burn through the whole window in auto research, and the results get fed back into Claude afterwards. It is crude, and the author jokes it may be the only use for it, but it shows people already scheduling autonomous loops around the reset clock rather than around the work.
https://x.com/dncipnci/status/2114124808497885455
dncipnci found a blunt use for quota windows: preplanned automated research tasks fire every time the five-hour window resets, burn through the whole window in auto research, and the results get fed back into Claude afterwards. It is crude, and the author jokes it may be the only use for it, but it shows people already scheduling autonomous loops around the reset clock rather than around the work.
#20
@mr_bytestorm
https://x.com/mr_bytestorm/status/2113988697360306629
mr_bytestorm's advice on autoresearch is narrow and useful: do not use the loops to come up with ideas for you. Give them your idea, then let them search for the best settings and run things in parallel, which is where current models are actually good, and ask them to build on the idea from there. It is the same division of labor the better experiments in this feed keep landing on, with the human picking the hypothesis and the loop doing the sweep.
https://x.com/mr_bytestorm/status/2113988697360306629
mr_bytestorm's advice on autoresearch is narrow and useful: do not use the loops to come up with ideas for you. Give them your idea, then let them search for the best settings and run things in parallel, which is where current models are actually good, and ask them to build on the idea from there. It is the same division of labor the better experiments in this feed keep landing on, with the human picking the hypothesis and the loop doing the sweep.
#21
@web3willbefree
https://x.com/web3willbefree/status/2114478216349905124
web3willbefree put the real cost of a loop in two sentences. Writing an agent loop takes an afternoon; deciding what context to cut takes the rest of the quarter. Trim one noisy tool output too aggressively and you did not save tokens, you gave the model amnesia right before the step that needed line 400 of the stack trace.
https://x.com/web3willbefree/status/2114478216349905124
web3willbefree put the real cost of a loop in two sentences. Writing an agent loop takes an afternoon; deciding what context to cut takes the rest of the quarter. Trim one noisy tool output too aggressively and you did not save tokens, you gave the model amnesia right before the step that needed line 400 of the stack trace.
#22
@IntuitMachine
https://x.com/IntuitMachine/status/2114140884296175790
IntuitMachine framed Anthropic's guide as Conway's Law for AI: give every team its own specialist subagent with an orchestrator on top and you get a Frankenprompt, lossy handoffs, subagent sprawl and twice the latency. The recommended fix is one main loop with progressive skills and tool search, where shared context and modern models often beat the multi-agent setup on quality, cost and speed. Subagents keep a place for true parallel work, context bloat and conflicting instructions, and everything else is described as organizational debt wearing an agent costume.
https://x.com/IntuitMachine/status/2114140884296175790
IntuitMachine framed Anthropic's guide as Conway's Law for AI: give every team its own specialist subagent with an orchestrator on top and you get a Frankenprompt, lossy handoffs, subagent sprawl and twice the latency. The recommended fix is one main loop with progressive skills and tool search, where shared context and modern models often beat the multi-agent setup on quality, cost and speed. Subagents keep a place for true parallel work, context bloat and conflicting instructions, and everything else is described as organizational debt wearing an agent costume.
#23
@bobbyhalljr_dev
https://x.com/bobbyhalljr_dev/status/2114469246365507788
bobbyhalljr_dev built a tiny TypeScript version of the pattern Anthropic recommends. The agent only sees short descriptions of skills and tools, and the full versions load when needed, the same progressive disclosure Anthropic credits for cutting Claude Code's system prompt by more than 80 percent. A small working implementation is worth more than another summary of the guide, and this was one of the few in the window.
https://x.com/bobbyhalljr_dev/status/2114469246365507788
bobbyhalljr_dev built a tiny TypeScript version of the pattern Anthropic recommends. The agent only sees short descriptions of skills and tools, and the full versions load when needed, the same progressive disclosure Anthropic credits for cutting Claude Code's system prompt by more than 80 percent. A small working implementation is worth more than another summary of the guide, and this was one of the few in the window.
#24
@Howard_Pengg
https://x.com/Howard_Pengg/status/2114011106041819157
Howard_Pengg pointed to AUV, which works like Playwright for the operating system: script the clicks and typing once, then replay them, with no agent loop at all and, per the repo, zero token cost. It already drives Apple Music, macOS media controls and the game Balatro. It is a useful counterweight to the loop discussion, because a lot of computer use does not need a model deciding every step.
https://x.com/Howard_Pengg/status/2114011106041819157
Howard_Pengg pointed to AUV, which works like Playwright for the operating system: script the clicks and typing once, then replay them, with no agent loop at all and, per the repo, zero token cost. It already drives Apple Music, macOS media controls and the game Balatro. It is a useful counterweight to the loop discussion, because a lot of computer use does not need a model deciding every step.
#25
@cyyeh0923
https://x.com/cyyeh0923/status/2114270940184072269
cyyeh0923 built Agent Loop Visualizer, an open-source learning project that draws every step of the loop that runs behind an agent's chat box, down to each token's probability. It runs on a small model on your own machine. For anyone who has only ever seen agents as a chat window, seeing the loop spelled out step by step is the fastest way to understand where it can go wrong.
https://x.com/cyyeh0923/status/2114270940184072269
cyyeh0923 built Agent Loop Visualizer, an open-source learning project that draws every step of the loop that runs behind an agent's chat box, down to each token's probability. It runs on a small model on your own machine. For anyone who has only ever seen agents as a chat window, seeing the loop spelled out step by step is the fastest way to understand where it can go wrong.
#26
@wongcken
https://x.com/wongcken/status/2113834608634831146
wongcken offered a role assignment inside an agentic loop. GPT does what it is told, apart from an overly defensive streak, and that trait, bad in a planner or worker, makes it a good reviewer of the loop. Opus can then trim the excess defensiveness at the next stage, which is a small, concrete version of the writer-reviewer split many builders now run across vendors.
https://x.com/wongcken/status/2113834608634831146
wongcken offered a role assignment inside an agentic loop. GPT does what it is told, apart from an overly defensive streak, and that trait, bad in a planner or worker, makes it a good reviewer of the loop. Opus can then trim the excess defensiveness at the next stage, which is a small, concrete version of the writer-reviewer split many builders now run across vendors.
#27
@ashpreetbedi
https://x.com/ashpreetbedi/status/2114407868736671935
ashpreetbedi says more and more teams now use data generated by their agents to improve their agent platforms. The notes cover how coding agents, evaluations and shared infrastructure together make self-improving agent platforms possible. It is a short pointer, but it names the loop that matters most for companies: agent traces turned into evals, and evals turned into platform changes.
https://x.com/ashpreetbedi/status/2114407868736671935
ashpreetbedi says more and more teams now use data generated by their agents to improve their agent platforms. The notes cover how coding agents, evaluations and shared infrastructure together make self-improving agent platforms possible. It is a short pointer, but it names the loop that matters most for companies: agent traces turned into evals, and evals turned into platform changes.
π‘ Eco Products Radar
Eco Products Radar
Anthropic's subagent folding guide: the single-loop advice most of the window repeated, tested or turned into playbooks.
Claude Code, Codex and OpenCode: the harnesses people took apart, rebuilt from scratch and routed work between.
OpenHands: the agent SDK whose harness still shipped working code with the model replaced by a script.
HarnessRouter and Grok Bot: the coordinator pattern running personal and corporate work across harnesses.
DeepSeek Harness and Pi: the other harnesses in routers, install-and-test runs and from-scratch courses.
MCP and Agent Skills: the packaging for price lookups, tools and the progressive disclosure behind the fold.
LangChain and Terminal-Bench: the same-model, better-harness result that keeps getting cited.
Firecracker microVMs: the sandbox layer people now prefer to Kubernetes pods for agent execution.
Anthropic's subagent folding guide: the single-loop advice most of the window repeated, tested or turned into playbooks.
Claude Code, Codex and OpenCode: the harnesses people took apart, rebuilt from scratch and routed work between.
OpenHands: the agent SDK whose harness still shipped working code with the model replaced by a script.
HarnessRouter and Grok Bot: the coordinator pattern running personal and corporate work across harnesses.
DeepSeek Harness and Pi: the other harnesses in routers, install-and-test runs and from-scratch courses.
MCP and Agent Skills: the packaging for price lookups, tools and the progressive disclosure behind the fold.
LangChain and Terminal-Bench: the same-model, better-harness result that keeps getting cited.
Firecracker microVMs: the sandbox layer people now prefer to Kubernetes pods for agent execution.
Comments