Loop Daily: 2026-10-16
The loop community spent the week agreeing on one diagnosis and arguing about the cure. The diagnosis: autoresearch agents plateau, and they plateau because of what they remember, not because of what they can do. The cure that landed this week is forgetting. A new paper from Berkeley and collaborators resets a team of agents to the best solution found so far and throws everything else away, and reports a win on all four tasks it tried, including Anthropic's VLIW kernel challenge and nanochat-autoresearch, with a 22% edge over a single long-running agent. The GEPA author traced the same idea back to a 2024 swarm of GPT-4o agents that cracked the o1 launch cipher by hiding part of the state from every worker. Meanwhile the decentralized integer-multiplication effort kept running the biggest live experiment: 518 pull requests in 24 hours from 64 contributors, a record that started from a PR whose own pricing said no improvement, and a side result that sharing context between agents hurt until checkpoint files replaced model-call summaries. Around the edges: an agent loop applied to robot control that patches its own positioning functions from IK errors, a hundred agents in microVMs on a Raspberry Pi, a DuckDB loop built in a weekend, a measured hour of an autonomous agent that cost $1.93 with caching and $6.92 without, and a harness builder who removed time estimates after the agent spent three days writing markdown instead of starting.
#1
@ShangyinT
https://x.com/ShangyinT/status/2110771398209863821
ShangyinT introduced the paper Scaling Discovery Requires Forgetting, starting from the observation that autoresearch with coding agents can now run for days on a single problem but increasingly stops improving early. The fix is forgetting: the team of agents is periodically reset and restarted from the best candidate only. In the companion threads the author lays out the three ways people scale an autoresearch agent with more compute, run one longer, run several in parallel, or let them talk, and notes that all three plateau long before the budget runs out. On four tasks, AtCoder Heuristic Contest 014, Frontier-CS Q171, Anthropic's VLIW kernel challenge and nanochat-autoresearch, the forgetting team was best on all four, averaging 10% over parallel agents and 22% over a single agent.
https://x.com/ShangyinT/status/2110771398209863821
ShangyinT introduced the paper Scaling Discovery Requires Forgetting, starting from the observation that autoresearch with coding agents can now run for days on a single problem but increasingly stops improving early. The fix is forgetting: the team of agents is periodically reset and restarted from the best candidate only. In the companion threads the author lays out the three ways people scale an autoresearch agent with more compute, run one longer, run several in parallel, or let them talk, and notes that all three plateau long before the budget runs out. On four tasks, AtCoder Heuristic Contest 014, Frontier-CS Q171, Anthropic's VLIW kernel challenge and nanochat-autoresearch, the forgetting team was best on all four, averaging 10% over parallel agents and 22% over a single agent.
#2
@AlexGDimakis
https://x.com/AlexGDimakis/status/2110808302796108249
AlexGDimakis, one of the paper's authors, gives the mechanism in two sentences: as agents perform autoresearch they fixate on their old ideas and only make incremental innovations, so a context management trick forces them to forget everything except the best solution found so far. That alone gets them out of their idea basins and produces more novel solutions. The post explicitly ties the work to Fork and Flush and the idea-basins framing posted days earlier, which makes this the third independent group to land on the same conclusion in two weeks.
https://x.com/AlexGDimakis/status/2110808302796108249
AlexGDimakis, one of the paper's authors, gives the mechanism in two sentences: as agents perform autoresearch they fixate on their old ideas and only make incremental innovations, so a context management trick forces them to forget everything except the best solution found so far. That alone gets them out of their idea basins and produces more novel solutions. The post explicitly ties the work to Fork and Flush and the idea-basins framing posted days earlier, which makes this the third independent group to land on the same conclusion in two weeks.
#3
@LakshyAAAgrawal
https://x.com/LakshyAAAgrawal/status/2110851700529791144
LakshyAAAgrawal, the GEPA author, adds the backstory. In September 2024 the headline example in OpenAI's o1 launch was a cipher GPT-4o could not break; the team built a swarm of GPT-4o workers where each one advanced the state while seeing only a stochastically selected subset of the state files, restarting with a fresh context each iteration, and that dropout swarm cracked the cipher in about 20 rounds. Those ideas became GEPA, whose proposer deliberately never sees the full state. Since then coding agents stretched a single run from a handful of calls to days, and the need to forget caught up; the omni pipeline now hands a stalled optimizer's best candidate to a fresh one, forgetting at the level of whole optimizers. The verdict: what an agent sees in context every iteration matters as much as how much compute it gets.
https://x.com/LakshyAAAgrawal/status/2110851700529791144
LakshyAAAgrawal, the GEPA author, adds the backstory. In September 2024 the headline example in OpenAI's o1 launch was a cipher GPT-4o could not break; the team built a swarm of GPT-4o workers where each one advanced the state while seeing only a stochastically selected subset of the state files, restarting with a fresh context each iteration, and that dropout swarm cracked the cipher in about 20 rounds. Those ideas became GEPA, whose proposer deliberately never sees the full state. Since then coding agents stretched a single run from a handful of calls to days, and the need to forget caught up; the omni pipeline now hands a stalled optimizer's best candidate to a fresh one, forgetting at the level of whole optimizers. The verdict: what an agent sees in context every iteration matters as much as how much compute it gets.
#4
@matei_zaharia
https://x.com/matei_zaharia/status/2110780634201497684
matei_zaharia summarized the paper in one line that explains why it matters for anyone running long loops: just running an agent for a long time can lock it into small steps in the same direction. Forgetting is how you break the lock.
https://x.com/matei_zaharia/status/2110780634201497684
matei_zaharia summarized the paper in one line that explains why it matters for anyone running long loops: just running an agent for a long time can lock it into small steps in the same direction. Forgetting is how you break the lock.
#5
@veds_12
https://x.com/veds_12/status/2110829249884213607
veds_12 reports the same trick working in practice on GitSwarm AutoResearch runs: run k independent swarms, and once they plateau, initialize a new workspace seeded with the best solutions of each as the starting commits. The successor workers combine ideas from different runs and escape the performance and ideation plateaus.
https://x.com/veds_12/status/2110829249884213607
veds_12 reports the same trick working in practice on GitSwarm AutoResearch runs: run k independent swarms, and once they plateau, initialize a new workspace seeded with the best solutions of each as the starting commits. The successor workers combine ideas from different runs and escape the performance and ideation plateaus.
#6
@SAkasxh
https://x.com/SAkasxh/status/2110766946031743292
SAkasxh frames it as inertia: more context is not always better memory, sometimes it is just more inertia. Fork-and-Flush preserves what an agent built but resets the reasoning that may be trapping it in a local minimum. The open question raised is whether exploration collapse can be detected early enough to fork before it happens rather than after.
https://x.com/SAkasxh/status/2110766946031743292
SAkasxh frames it as inertia: more context is not always better memory, sometimes it is just more inertia. Fork-and-Flush preserves what an agent built but resets the reasoning that may be trapping it in a local minimum. The open question raised is whether exploration collapse can be detected early enough to fork before it happens rather than after.
#7
@RohanArun
https://x.com/RohanArun/status/2110748916412993915
RohanArun's integer multiplication update covers the breakthrough and the flood. Progress had slowed for days, then 1337isnot1337 posted a research PR on anticipatory dirty borrowing, where a helper borrows an idle register and hands it back restored, cutting helpers per call from 480 to 400 even though its own pricing said no new kappa; two hours later it was a record, and 19 kappa PRs from six contributors stacked on top for a 1.4% gain in 13 hours. The last 24 hours brought 518 PRs from 64 contributors, 20 of them first-timers, and 760 were merged in two batches. Codex is mentioned in 73% of the day's PRs and Claude in 19%. Early auto-researchers are branching out: one to protein design, one who found 665 exoplanet candidates in NASA TESS data, and the author to a new self-attention geometry that beats a NanoGPT KV cache with 14,000x less state.
https://x.com/RohanArun/status/2110748916412993915
RohanArun's integer multiplication update covers the breakthrough and the flood. Progress had slowed for days, then 1337isnot1337 posted a research PR on anticipatory dirty borrowing, where a helper borrows an idle register and hands it back restored, cutting helpers per call from 480 to 400 even though its own pricing said no new kappa; two hours later it was a record, and 19 kappa PRs from six contributors stacked on top for a 1.4% gain in 13 hours. The last 24 hours brought 518 PRs from 64 contributors, 20 of them first-timers, and 760 were merged in two batches. Codex is mentioned in 73% of the day's PRs and Claude in 19%. Early auto-researchers are branching out: one to protein design, one who found 665 exoplanet candidates in NASA TESS data, and the author to a new self-attention geometry that beats a NanoGPT KV cache with 14,000x less state.
#8
@RohanArun
https://x.com/RohanArun/status/2110853074927423709
RohanArun also reports the first results of using frontier research as an agent benchmark: rewind the integer multiplication repo to an earlier branch, disable web search, and test harnesses, prompts and context strategies against a known future. Naive context sharing added minutes of overhead through paraphrasing model calls, so the harness was changed to have agents keep compact checkpoint files while working, concatenate them on a schedule, and hand each successor the combined context in a fresh session with no model call in between. Parallel agents in cloud sandboxes beat a MacBook Pro, adding agents improves results with diminishing returns, and sharing too often is still bad because agents spend less time working. The results are published in the open-source auto-research harness.
https://x.com/RohanArun/status/2110853074927423709
RohanArun also reports the first results of using frontier research as an agent benchmark: rewind the integer multiplication repo to an earlier branch, disable web search, and test harnesses, prompts and context strategies against a known future. Naive context sharing added minutes of overhead through paraphrasing model calls, so the harness was changed to have agents keep compact checkpoint files while working, concatenate them on a schedule, and hand each successor the combined context in a fresh session with no model call in between. Parallel agents in cloud sandboxes beat a MacBook Pro, adding agents improves results with diminishing returns, and sharing too often is still bad because agents spend less time working. The results are published in the open-source auto-research harness.
#9
@RohanArun
https://x.com/RohanArun/status/2110497539896009167
RohanArun's own autoresearch output is a new geometric approach to self-attention, worked on with a Google researcher and a former professor for months. Weights are represented as functions in GPU memory rather than materialized, so the model can sample new layers at inference from a curve, eight for a phone and 24 for a server. A hierarchical state beats the NanoGPT KV cache with 14,000x less state and 50% better cross-entropy at 2K context, forward-pass perturbations between pre-training steps optimize without tokens, and experts are cached with a bundling trick. The week Fable dropped, progress exploded with auto-research, and the author is open-sourcing it rather than waiting on a paper.
https://x.com/RohanArun/status/2110497539896009167
RohanArun's own autoresearch output is a new geometric approach to self-attention, worked on with a Google researcher and a former professor for months. Weights are represented as functions in GPU memory rather than materialized, so the model can sample new layers at inference from a curve, eight for a phone and 24 for a server. A hierarchical state beats the NanoGPT KV cache with 14,000x less state and 50% better cross-entropy at 2K context, forward-pass perturbations between pre-training steps optimize without tokens, and experts are cached with a bundling trick. The week Fable dropped, progress exploded with auto-research, and the author is open-sourcing it rather than waiting on a paper.
#10
@arankomatsuzaki
https://x.com/arankomatsuzaki/status/2110252109102997613
arankomatsuzaki highlights CRIS-0, where the coding-agent loop is applied to robot control. The agent generates its own positioning functions from demonstrations using SAM3, RGB-D and inverse kinematics; when a function hits an IK joint limit, it patches the function from the error message, retries the stage, and keeps the patched version.
https://x.com/arankomatsuzaki/status/2110252109102997613
arankomatsuzaki highlights CRIS-0, where the coding-agent loop is applied to robot control. The agent generates its own positioning functions from demonstrations using SAM3, RGB-D and inverse kinematics; when a function hits an IK joint limit, it patches the function from the error message, retries the stage, and keeps the patched version.
#11
@tszzl
https://x.com/tszzl/status/2110760793696616581
tszzl reports that against the predictions of most experts, neurons and experts inside models turned out to be sensible abstractions that can be studied through normal poking and probing, and credits agentic auto-research with making the difference. The claim is that mechanistic interpretability will reveal what goes on inside models within the timeframes that matter, with the caveat that much corroboration is still needed.
https://x.com/tszzl/status/2110760793696616581
tszzl reports that against the predictions of most experts, neurons and experts inside models turned out to be sensible abstractions that can be studied through normal poking and probing, and credits agentic auto-research with making the difference. The claim is that mechanistic interpretability will reveal what goes on inside models within the timeframes that matter, with the caveat that much corroboration is still needed.
#12
@jafermarq
https://x.com/jafermarq/status/2110430320528921039
jafermarq ran more than 100 AI agents, each in its own microVM with its own memory and file system, on one Raspberry Pi 5 with four cores and 8 GB of RAM, with room to spare. Each agent has a me.md describing who it is and how it talks, a leader searches the web and keeps what it finds, and a lightweight agent loop makes it work with any LLM, local or through OpenRouter. The run was recorded on the Pi.
https://x.com/jafermarq/status/2110430320528921039
jafermarq ran more than 100 AI agents, each in its own microVM with its own memory and file system, on one Raspberry Pi 5 with four cores and 8 GB of RAM, with room to spare. Each agent has a me.md describing who it is and how it talks, a leader searches the web and keeps what it finds, and a lightweight agent loop makes it work with any LLM, local or through OpenRouter. The run was recorded on the Pi.
#13
@orca_build
https://x.com/orca_build/status/2110386898858319969
orca_build shows a worktree that contains a whole team of worktrees: a manager agent in the parent spins up isolated nested worktrees, each running its own agent loop, oversees the team and makes sure everything lands in order. Nested worktrees across repos are next, so one manager can coordinate changes to a frontend, a backend and shared libraries.
https://x.com/orca_build/status/2110386898858319969
orca_build shows a worktree that contains a whole team of worktrees: a manager agent in the parent spins up isolated nested worktrees, each running its own agent loop, oversees the team and makes sure everything lands in order. Nested worktrees across repos are next, so one manager can coordinate changes to a frontend, a backend and shared libraries.
#14
@HoytEmerson
https://x.com/HoytEmerson/status/2110185183488160171
HoytEmerson built a first agent loop proof of concept on DuckDB and is hooked. The takeaway offered is that nobody should try to recreate Claude Code, but a surprising number of jobs do not need Claude Code at all. Next step is cleaning it up and hardening it.
https://x.com/HoytEmerson/status/2110185183488160171
HoytEmerson built a first agent loop proof of concept on DuckDB and is hooked. The takeaway offered is that nobody should try to recreate Claude Code, but a surprising number of jobs do not need Claude Code at all. Next step is cleaning it up and hardening it.
#15
@stalkermustang
https://x.com/stalkermustang/status/2110837413551411231
stalkermustang announced a robotics effort that pairs the autoresearch wave with reproducibility. The pitch: frontier coding agents can now run experiments and iterate, while reproducing a robotics paper still means curating datasets, handling annotations, setting up hardware and running real-world evaluations even when the code is public. The plan is to let agents automate most of the implementation work and combine them with robotics infrastructure for real-world evaluation at scale.
https://x.com/stalkermustang/status/2110837413551411231
stalkermustang announced a robotics effort that pairs the autoresearch wave with reproducibility. The pitch: frontier coding agents can now run experiments and iterate, while reproducing a robotics paper still means curating datasets, handling annotations, setting up hardware and running real-world evaluations even when the code is public. The plan is to let agents automate most of the implementation work and combine them with robotics infrastructure for real-world evaluation at scale.
#16
@pauliusztin_
https://x.com/pauliusztin_/status/2110374719580962839
pauliusztin_ is letting readers pick the next open-source series on a production long-running agent, and the three candidates are a map of where loops are going. One: Karpathy's autoresearch applied to coding, with a goal plus evals as a loss function, iterating until the threshold is met, calibrated against videos and articles you already like. Two: agents that run overnight on unused subscription credits to refactor, clean or research features, capped to leave credits for the morning, pulling tickets from Linear or Sentry errors into one worktree and draft PR each. Three: deep research specialized for agentic coding that mines codebases, articles and papers for the right pattern before implementing.
https://x.com/pauliusztin_/status/2110374719580962839
pauliusztin_ is letting readers pick the next open-source series on a production long-running agent, and the three candidates are a map of where loops are going. One: Karpathy's autoresearch applied to coding, with a goal plus evals as a loss function, iterating until the threshold is met, calibrated against videos and articles you already like. Two: agents that run overnight on unused subscription credits to refactor, clean or research features, capped to leave credits for the morning, pulling tickets from Linear or Sentry errors into one worktree and draft PR each. Three: deep research specialized for agentic coding that mines codebases, articles and papers for the right pattern before implementing.
#17
@PriyankShethia
https://x.com/PriyankShethia/status/2110766598789501343
PriyankShethia co-led SHELDON, built on the question of whether the next breakthrough is not a better hypothesis but an observation no one thought to look for. It explores both and reports strong results in medical diagnosis, system analysis, ARC-AGI-2 and autoresearch. The co-lead's numbers: by embedding every program and taking the convex hull, SHELDON covers 1.4 to 20.9 times more space than the strongest baseline on five of six autoresearch tasks, and on tasks with no scoring function it investigates five distinct ideas per case versus 1.5, winning 73 of 75.
https://x.com/PriyankShethia/status/2110766598789501343
PriyankShethia co-led SHELDON, built on the question of whether the next breakthrough is not a better hypothesis but an observation no one thought to look for. It explores both and reports strong results in medical diagnosis, system analysis, ARC-AGI-2 and autoresearch. The co-lead's numbers: by embedding every program and taking the convex hull, SHELDON covers 1.4 to 20.9 times more space than the strongest baseline on five of six autoresearch tasks, and on tasks with no scoring function it investigates five distinct ideas per case versus 1.5, winning 73 of 75.
#18
@hammer_mt
https://x.com/hammer_mt/status/2110859049944207779
hammer_mt is playing with Heisentools, which borrows the heisenfunction idea and combines it with autoresearch: make a fake service and have an agent rewrite mock.py until it mirrors the real tool calls it has observed and can extrapolate to new ones. The payoff is simulating any service while testing agents, avoiding rate limits, context drift and polluting a database with test calls. It was tested on real Slack messages and should work for any service.
https://x.com/hammer_mt/status/2110859049944207779
hammer_mt is playing with Heisentools, which borrows the heisenfunction idea and combines it with autoresearch: make a fake service and have an agent rewrite mock.py until it mirrors the real tool calls it has observed and can extrapolate to new ones. The payoff is simulating any service while testing agents, avoiding rate limits, context drift and polluting a database with test calls. It was tested on real Slack messages and should work for any service.
#19
@opcastil
https://x.com/opcastil/status/2110449305232245081
opcastil measured one hour of an autonomous LLM agent in production, an agent playing a game alone on DeepSeek: 356 calls, 25.2 million input tokens, 108,000 output tokens, a bill of $1.93, and $6.92 without prompt caching. The linked write-up is about what actually decides the cost of a long agent loop.
https://x.com/opcastil/status/2110449305232245081
opcastil measured one hour of an autonomous LLM agent in production, an agent playing a game alone on DeepSeek: 356 calls, 25.2 million input tokens, 108,000 output tokens, a bill of $1.93, and $6.92 without prompt caching. The linked write-up is about what actually decides the cost of a long agent loop.
#20
@newlinedotco
https://x.com/newlinedotco/status/2110778518669848780
newlinedotco turns a Meta Superintelligence Labs paper into an interview question: your self-improving agent keeps writing notes, tools and skills, and its held-out score is not moving, where do you look first. Across eight models playing chess the data points to two checks in order. First, does it use what it wrote: when a saved note applied, some models skipped it 87% to 98% of the time, while Fable 5, Opus 5, Opus 4.8 and GPT-5.6 Sol skipped it 2% to 6%, and low reuse went with weak improvement. Second, when it uses them does it still fail: agents that used notes at almost every relevant move failed less, 0.16 versus 0.38 per relevant decision, yet 83% to 99% of their remaining failures happened while a note was in use. The fixes are to auto-load notes so they are harder to skip, and to test whether a note helps rather than whether it runs.
https://x.com/newlinedotco/status/2110778518669848780
newlinedotco turns a Meta Superintelligence Labs paper into an interview question: your self-improving agent keeps writing notes, tools and skills, and its held-out score is not moving, where do you look first. Across eight models playing chess the data points to two checks in order. First, does it use what it wrote: when a saved note applied, some models skipped it 87% to 98% of the time, while Fable 5, Opus 5, Opus 4.8 and GPT-5.6 Sol skipped it 2% to 6%, and low reuse went with weak improvement. Second, when it uses them does it still fail: agents that used notes at almost every relevant move failed less, 0.16 versus 0.38 per relevant decision, yet 83% to 99% of their remaining failures happened while a note was in use. The fixes are to auto-load notes so they are harder to skip, and to test whether a note helps rather than whether it runs.
#21
@RomanGuy20
https://x.com/RomanGuy20/status/2110492649342058891
RomanGuy20 describes an automated research pipeline: it takes a base idea and runs an autoresearch-style loop, mutating and steering as results come in, using Cursor cloud runs to modify the logic, exe.dev to host, and Tinker to do the actual fine-tuning and serve tuned versions for testing. On Grok Bot the roles are a research lead, a code manager, QA, an exe.dev admin, a Tinker assistant, and a validator that checks the experiments are correct and relevant to the paper topic being built.
https://x.com/RomanGuy20/status/2110492649342058891
RomanGuy20 describes an automated research pipeline: it takes a base idea and runs an autoresearch-style loop, mutating and steering as results come in, using Cursor cloud runs to modify the logic, exe.dev to host, and Tinker to do the actual fine-tuning and serve tuned versions for testing. On Grok Bot the roles are a research lead, a code manager, QA, an exe.dev admin, a Tinker assistant, and a validator that checks the experiments are correct and relevant to the paper topic being built.
#22
@michael_timbs
https://x.com/michael_timbs/status/2110507020294258888
michael_timbs shares a harness-building failure worth copying into every autoresearch design doc. The first version asked agents for time estimates so they could prioritize work within the allotted time and avoid wasting compute on low-probability avenues. The rule had to be removed because every estimate was far too high, and the agent spent its first three days writing markdown files without starting any work.
https://x.com/michael_timbs/status/2110507020294258888
michael_timbs shares a harness-building failure worth copying into every autoresearch design doc. The first version asked agents for time estimates so they could prioritize work within the allotted time and avoid wasting compute on low-probability avenues. The rule had to be removed because every estimate was far too high, and the agent spent its first three days writing markdown files without starting any work.
#23
@nasqret
https://x.com/nasqret/status/2110769485674369390
nasqret is excited about a new team auto-research challenge aimed at finding elliptic curves of extremely large rank, and expects the format to pull in many contributors the way the integer multiplication effort did.
https://x.com/nasqret/status/2110769485674369390
nasqret is excited about a new team auto-research challenge aimed at finding elliptic curves of extremely large rank, and expects the format to pull in many contributors the way the integer multiplication effort did.
#24
@bradneuberg
https://x.com/bradneuberg/status/2110617626305310882
bradneuberg describes a separate issue tracker used as a kind of AI collective unconscious: issues to work on are recorded there, auto-research loops run against it, and every line of code produced by those loops is at least scanned by a human before it lands.
https://x.com/bradneuberg/status/2110617626305310882
bradneuberg describes a separate issue tracker used as a kind of AI collective unconscious: issues to work on are recorded there, auto-research loops run against it, and every line of code produced by those loops is at least scanned by a human before it lands.
#25
@stretchcloud
https://x.com/stretchcloud/status/2110526568699142323
stretchcloud notes that Claude Platform now ships OpenTelemetry traces from the Messages API, managed agents and the SDKs in public beta, and argues the interesting move is standardizing on OTel instead of a proprietary dashboard. The agent observability layer has fragmented into at least seven products with incompatible pricing, from Langfuse at $29 a month to Braintrust at $249, most of which assume they own the agent loop. Once managed agents emit standard spans, any vendor can ingest them, so the competition moves from data capture to evals, alerting, cost attribution and root-causing a bad run at 2am. The bet: the eval layer is the next fight, not tracing.
https://x.com/stretchcloud/status/2110526568699142323
stretchcloud notes that Claude Platform now ships OpenTelemetry traces from the Messages API, managed agents and the SDKs in public beta, and argues the interesting move is standardizing on OTel instead of a proprietary dashboard. The agent observability layer has fragmented into at least seven products with incompatible pricing, from Langfuse at $29 a month to Braintrust at $249, most of which assume they own the agent loop. Once managed agents emit standard spans, any vendor can ingest them, so the competition moves from data capture to evals, alerting, cost attribution and root-causing a bad run at 2am. The bet: the eval layer is the next fight, not tracing.
#26
@BIGBULLapp
https://x.com/BIGBULLapp/status/2110452959335330270
BIGBULLapp points to Dive into Claude Code, a systematic analysis from VILA-Lab built from version 2.1.88, about 1,900 TypeScript files and 512,000 lines. The punchline is architectural: the agent loop is a simple while loop and only 1.6% of the code does the thinking, while permission gates, context management, tool routing and recovery logic carry the other 98.4%. The collection has 2,167 stars, is pinned to one version so details drift as the product moves, and is called the clearest map of why agents are mostly plumbing with a little brain on top.
https://x.com/BIGBULLapp/status/2110452959335330270
BIGBULLapp points to Dive into Claude Code, a systematic analysis from VILA-Lab built from version 2.1.88, about 1,900 TypeScript files and 512,000 lines. The punchline is architectural: the agent loop is a simple while loop and only 1.6% of the code does the thinking, while permission gates, context management, tool routing and recovery logic carry the other 98.4%. The collection has 2,167 stars, is pinned to one version so details drift as the product moves, and is called the clearest map of why agents are mostly plumbing with a little brain on top.
#27
@siDandott
https://x.com/siDandott/status/2110352302796337249
siDandott frames Chainguard Checks, launched in beta on October 14, as CI moved inside the agent loop: verification becomes a tool call, the agent suspends, runs checks, and resumes with the failure logs. Each check runs in its own isolated microVM with no long-lived secrets on the runner and no network unless the check lists egress hosts, and a passing run yields a signed attestation that merge gates can verify instead of re-running the suite. The question posed is who verifies your agents' work today.
https://x.com/siDandott/status/2110352302796337249
siDandott frames Chainguard Checks, launched in beta on October 14, as CI moved inside the agent loop: verification becomes a tool call, the agent suspends, runs checks, and resumes with the failure logs. Each check runs in its own isolated microVM with no long-lived secrets on the runner and no network unless the check lists egress hosts, and a passing run yields a signed attestation that merge gates can verify instead of re-running the suite. The question posed is who verifies your agents' work today.
π‘ Eco Products Radar
Eco Products Radar
Scaling Discovery Requires Forgetting: the paper of the week, reset the team to the best candidate and discard the rest, wins on all four tasks including Anthropic's VLIW kernel challenge and nanochat-autoresearch
Fork-and-Flush, Stateless Language Agents, idea basins, GEPA: the four prior results every forgetting post now cites, three independent groups on one conclusion in two weeks
Integer multiplication community repo: 518 PRs in 24 hours, 64 contributors, 760 merged in two batches, Codex in 73% of PRs and Claude in 19%
Codex (OpenAI) and Claude Code: the two harnesses doing the PR flood, with Claude Code also the subject of a 512,000-line architecture study
Grok Bot (xAI): the role host for a full research pipeline, research lead, code manager, QA, validator, and the always-on agent people are reverse-engineering
Google Deep Review: auto-peer-review, more than 16,000 papers reviewed at ICML, NeurIPS and ICLR
Firecracker and microVMs: the isolation unit in Perplexity's SPACE, Chainguard Harness and Checks, and 100 agents on a Raspberry Pi
OpenTelemetry on Claude Platform: standard spans from managed agents, with Langfuse, LangSmith, Arize Phoenix, Braintrust and Helicone named as the fragmented layer above it
Orca: nested worktrees with a manager agent per parent
Tinker and Cursor cloud runs: the fine-tuning and code-edit substrate in the Grok Bot research pipeline
DuckDB: a weekend agent loop that convinced its author most jobs do not need Claude Code
Scaling Discovery Requires Forgetting: the paper of the week, reset the team to the best candidate and discard the rest, wins on all four tasks including Anthropic's VLIW kernel challenge and nanochat-autoresearch
Fork-and-Flush, Stateless Language Agents, idea basins, GEPA: the four prior results every forgetting post now cites, three independent groups on one conclusion in two weeks
Integer multiplication community repo: 518 PRs in 24 hours, 64 contributors, 760 merged in two batches, Codex in 73% of PRs and Claude in 19%
Codex (OpenAI) and Claude Code: the two harnesses doing the PR flood, with Claude Code also the subject of a 512,000-line architecture study
Grok Bot (xAI): the role host for a full research pipeline, research lead, code manager, QA, validator, and the always-on agent people are reverse-engineering
Google Deep Review: auto-peer-review, more than 16,000 papers reviewed at ICML, NeurIPS and ICLR
Firecracker and microVMs: the isolation unit in Perplexity's SPACE, Chainguard Harness and Checks, and 100 agents on a Raspberry Pi
OpenTelemetry on Claude Platform: standard spans from managed agents, with Langfuse, LangSmith, Arize Phoenix, Braintrust and Helicone named as the fragmented layer above it
Orca: nested worktrees with a manager agent per parent
Tinker and Cursor cloud runs: the fine-tuning and code-edit substrate in the Grok Bot research pipeline
DuckDB: a weekend agent loop that convinced its author most jobs do not need Claude Code
Comments