Loop Daily: August 7, 2026
The loop world got its biggest product launch in weeks: Prime Intellect shipped Prime Agent, a self-improving harness whose headline number — Opus 5 jumping from 30.2% to 95.5% on ARC-AGI-3 with no model change — instantly coined the phrase "Harness General Intelligence." The same day, Meta released Muse Code with auto-research baked into its training, and the public-autoresearch movement added a third arena: a live crypto exchange putting $30k in prizes on verified prover speedups, joining Apple Silicon inference and Ethereum SNARKs. Underneath the launches, the practitioners kept reporting the same two lessons: the loop escapes code easily (Tetris coaching, MRI age prediction, layer re-quantization on a GPU-less ThinkPad), and the evaluator — code the agent cannot touch — is still where all the real engineering lives.
#1
@PrimeIntellect
https://x.com/PrimeIntellect/status/2085086999267144083
Prime Intellect launched Prime Agent, a self-improving RLM harness for coding and long-running autonomous tasks. It is built around programmatic tool calling, context treated as a variable, multi-agent messaging, and a harness state the agent itself can modify. The launch post pulled two million impressions in a day, making it the most visible self-improving-agent release since Karpathy's autoresearch.
https://x.com/PrimeIntellect/status/2085086999267144083
Prime Intellect launched Prime Agent, a self-improving RLM harness for coding and long-running autonomous tasks. It is built around programmatic tool calling, context treated as a variable, multi-agent messaging, and a harness state the agent itself can modify. The launch post pulled two million impressions in a day, making it the most visible self-improving-agent release since Karpathy's autoresearch.
#2
@samsja19
https://x.com/samsja19/status/2085119070576537694
A Prime Intellect researcher shared a month of daily first-hand use of Prime Agent with both open and closed models. The RLM side gives programmatic tool calling and a persistent IPython kernel that survives compaction, acting as long-term memory, plus a subagent daemon and UI. The self-improving part is a continual harness: the model has tools to programmatically edit its own harness and skills as it works.
https://x.com/samsja19/status/2085119070576537694
A Prime Intellect researcher shared a month of daily first-hand use of Prime Agent with both open and closed models. The RLM side gives programmatic tool calling and a persistent IPython kernel that survives compaction, acting as long-term memory, plus a subagent daemon and UI. The self-improving part is a continual harness: the model has tools to programmatically edit its own harness and skills as it works.
#3
@daniel_mac8
https://x.com/daniel_mac8/status/2085138322217713862
The number that traveled: Prime Agent lifts Opus 5 from 30.2% to 95.5% on ARC-AGI-3 purely through the harness — same model, three times the score. The author dubs it "Harness General Intelligence" and attributes the gain to RLM-native tool calling, multi-agent orchestration, and the self-improving harness. If a wrapper can triple a frontier model's score on a reasoning benchmark, the benchmark now measures the harness as much as the model.
https://x.com/daniel_mac8/status/2085138322217713862
The number that traveled: Prime Agent lifts Opus 5 from 30.2% to 95.5% on ARC-AGI-3 purely through the harness — same model, three times the score. The author dubs it "Harness General Intelligence" and attributes the gain to RLM-native tool calling, multi-agent orchestration, and the self-improving harness. If a wrapper can triple a frontier model's score on a reasoning benchmark, the benchmark now measures the harness as much as the model.
#4
@eigenlabs
https://x.com/eigenlabs/status/2085026915606311165
EigenLabs and Lighter launched an open autoresearch challenge on a live, cryptographically proven exchange: point your agent at the prover, find an optimization, submit a verified speedup, and share 15K LIT (about $30k) in prizes. It is public autoresearch on production infrastructure — the verification is cryptographic, so the judge problem is solved by construction.
https://x.com/eigenlabs/status/2085026915606311165
EigenLabs and Lighter launched an open autoresearch challenge on a live, cryptographically proven exchange: point your agent at the prover, find an optimization, submit a verified speedup, and share 15K LIT (about $30k) in prizes. It is public autoresearch on production infrastructure — the verification is cryptographic, so the judge problem is solved by construction.
#5
@will__price
https://x.com/will__price/status/2085040214225858939
The one-line summary of why the Lighter challenge works: proofs are expensive to generate but cheap to verify, a perfect domain for AI optimization. Domains with that asymmetry — generation costly, verification instant and trustless — are exactly where autonomous optimization loops can run without a human judge.
https://x.com/will__price/status/2085040214225858939
The one-line summary of why the Lighter challenge works: proofs are expensive to generate but cheap to verify, a perfect domain for AI optimization. Domains with that asymmetry — generation costly, verification instant and trustless — are exactly where autonomous optimization loops can run without a human judge.
#6
@bbuddha_xyz
https://x.com/bbuddha_xyz/status/2085048248943903112
The public-autoresearch pattern now has three named arenas: Lighter running public autoresearch to make its chain faster, darkbloom running mlx.fast to speed up Apple Silicon inference, and the Ethereum Foundation running snark.fast for SNARK proving. Companies are starting to open their R&D bottlenecks to anyone's agents, paying only for verified wins.
https://x.com/bbuddha_xyz/status/2085048248943903112
The public-autoresearch pattern now has three named arenas: Lighter running public autoresearch to make its chain faster, darkbloom running mlx.fast to speed up Apple Silicon inference, and the Ethereum Foundation running snark.fast for SNARK proving. Companies are starting to open their R&D bottlenecks to anyone's agents, paying only for verified wins.
#7
@LambdaAPI
https://x.com/LambdaAPI/status/2084985044041601508
Lambda highlighted an autoresearch run where Claude Code coached a frozen Gemma 4 model at Tetris — the model's weights never changed, only the coaching. Caged with an experiment tracker, the loop went from 0 to 16 cleared lines in 2.5 days, generated 90 ideas, ran 400+ experiments, and got 10x cheaper by the end. Every run was logged in The Lab API, which is now open source.
https://x.com/LambdaAPI/status/2084985044041601508
Lambda highlighted an autoresearch run where Claude Code coached a frozen Gemma 4 model at Tetris — the model's weights never changed, only the coaching. Caged with an experiment tracker, the loop went from 0 to 16 cleared lines in 2.5 days, generated 90 ideas, ran 400+ experiments, and got 10x cheaper by the end. Every run was logged in The Lab API, which is now open source.
#8
@davis7
https://x.com/davis7/status/2085113373805687241
A detailed field report on running DeepSeek V4 Flash 0731 locally through Pi — "basically Opus 4.6 running in my closet." The honest downsides: expensive setup, weaker than frontier, 2-4 sessions max. But it shines on two things: work in domains where hosted models refuse, and any verifiable problem you can drop into an auto-research loop and let grind. His rule: anything brute-forceable is perfect for local models; open-ended work still needs the frontier.
https://x.com/davis7/status/2085113373805687241
A detailed field report on running DeepSeek V4 Flash 0731 locally through Pi — "basically Opus 4.6 running in my closet." The honest downsides: expensive setup, weaker than frontier, 2-4 sessions max. But it shines on two things: work in domains where hosted models refuse, and any verifiable problem you can drop into an auto-research loop and let grind. His rule: anything brute-forceable is perfect for local models; open-ended work still needs the frontier.
#9
@Marktechpost
https://x.com/Marktechpost/status/2085098231965585908
A breakdown of Meta's Muse Code beta: a simple agent loop plus persistent async background agents, an append-only event log making the runtime replay-exact and restart-safe, and a model (Muse Spark 1.2) co-trained with the harness on whole-repo generation and auto-research. The flagship case study is iterative GPU kernel optimization over 1,000+ tool calls in runs up to 24 hours, producing a two-kernel Triton pipeline for MLA on Hopper.
https://x.com/Marktechpost/status/2085098231965585908
A breakdown of Meta's Muse Code beta: a simple agent loop plus persistent async background agents, an append-only event log making the runtime replay-exact and restart-safe, and a model (Muse Spark 1.2) co-trained with the harness on whole-repo generation and auto-research. The flagship case study is iterative GPU kernel optimization over 1,000+ tool calls in runs up to 24 hours, producing a two-kernel Triton pipeline for MLA on Hopper.
#10
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2085089809371173362
Meta chief AI officer Alexandr Wang at YC Startup School: with the right agentic loop and the right eval metric, a swarm of agents accomplishes more than a team of 100 engineers, "very handily, actually very easily" — and the machinery is markdown files and cron jobs. The quote reframes the leverage point: writing the metric now matters more than writing the code.
https://x.com/rohanpaul_ai/status/2085089809371173362
Meta chief AI officer Alexandr Wang at YC Startup School: with the right agentic loop and the right eval metric, a swarm of agents accomplishes more than a team of 100 engineers, "very handily, actually very easily" — and the machinery is markdown files and cron jobs. The quote reframes the leverage point: writing the metric now matters more than writing the code.
#11
@evanjconrad
https://x.com/evanjconrad/status/2084819797133721679
San Francisco Compute launched an autoresearch product: tell an agent "download this model off HuggingFace and optimize it 4x, don't stop until done" and let it run for days. The design is agent-first — a fair queue so experiments always get GPU space, jobs that restart from checkpoints, and ticketing built into the MCP so the agent can recover from platform outages on its own. They tested by taking the platform down mid-run; agent-supervised training kept going.
https://x.com/evanjconrad/status/2084819797133721679
San Francisco Compute launched an autoresearch product: tell an agent "download this model off HuggingFace and optimize it 4x, don't stop until done" and let it run for days. The design is agent-first — a fair queue so experiments always get GPU space, jobs that restart from checkpoints, and ticketing built into the MCP so the agent can recover from platform outages on its own. They tested by taking the platform down mid-run; agent-supervised training kept going.
#12
@antnjbert
https://x.com/antnjbert/status/2085095173734777163
A clean science example: after posting about auto-research a few days ago, the author added NVIDIA support and left agents running for several days to find new ways to improve vision transformer accuracy at predicting age from MRI images. Autoresearch as unattended hypothesis search on a real medical-imaging problem.
https://x.com/antnjbert/status/2085095173734777163
A clean science example: after posting about auto-research a few days ago, the author added NVIDIA support and left agents running for several days to find new ways to improve vision transformer accuracy at predicting age from MRI images. Autoresearch as unattended hypothesis search on a real medical-imaging problem.
#13
@ljupc0
https://x.com/ljupc0/status/2084975395628024037
Auto-research on the smallest hardware yet: OMP with DeepSeek-v4-flash on an old GPU-less ThinkPad. The author downloaded a SKILL.md, pointed /goal at it, and four hours later the loop had re-quantized several 6-bit layers to 4-bit to fit the laptop's memory bandwidth. Ten minutes of setup, ten minutes reviewing results — and his summary of why loops win: "never ever do I want to be the one nursing the negative results."
https://x.com/ljupc0/status/2084975395628024037
Auto-research on the smallest hardware yet: OMP with DeepSeek-v4-flash on an old GPU-less ThinkPad. The author downloaded a SKILL.md, pointed /goal at it, and four hours later the loop had re-quantized several 6-bit layers to 4-bit to fit the laptop's memory bandwidth. Ten minutes of setup, ten minutes reviewing results — and his summary of why loops win: "never ever do I want to be the one nursing the negative results."
#14
@noctus91
https://x.com/noctus91/status/2085014991477047761
An experiment worth copying: a local Agent Firewall built with Mistral's open-sourced Shieldstral, inspecting three stages of the agent loop — user input, tool outputs (files, terminal, PDFs, images, AGENTS.md), and the final response — before content reaches the agent. Tested against prompt injections and hidden instructions in PDFs and images from the L1B3RT4S repository. The author's bet: agent firewalls become as standard as agent sandboxes.
https://x.com/noctus91/status/2085014991477047761
An experiment worth copying: a local Agent Firewall built with Mistral's open-sourced Shieldstral, inspecting three stages of the agent loop — user input, tool outputs (files, terminal, PDFs, images, AGENTS.md), and the final response — before content reaches the agent. Tested against prompt injections and hidden instructions in PDFs and images from the L1B3RT4S repository. The author's bet: agent firewalls become as standard as agent sandboxes.
#15
@mikenevermiss
https://x.com/mikenevermiss/status/2084910738783494474
Relays an Anthropic engineer's claim that building loops without a self-improving eval agent is the mistake that cost them two years. The fix is concrete: run 50 real prompts targeting ~50% pass rate, turn every failure into a transcript analyzed by Haiku so the eval set grows itself, score both answer and path, and re-run evals on every new model — which once caught 6 points of an apparent 9-point gain coming from a hidden bug.
https://x.com/mikenevermiss/status/2084910738783494474
Relays an Anthropic engineer's claim that building loops without a self-improving eval agent is the mistake that cost them two years. The fix is concrete: run 50 real prompts targeting ~50% pass rate, turn every failure into a transcript analyzed by Haiku so the eval set grows itself, score both answer and path, and re-run evals on every new model — which once caught 6 points of an apparent 9-point gain coming from a hidden bug.
#16
@Vtrivedy10
https://x.com/Vtrivedy10/status/2084851298050969841
A mildly hot take that matches the day's launches: the general-purpose harness is a myth. You can strip away most of any harness (see Pi, deepagents) and get better, cheaper performance, then customize a base harness for your tasks via auto-research, human review, and a few skills. Harnesses are not just made, they are discovered from evals — which is where teams that want to own their harness will end up.
https://x.com/Vtrivedy10/status/2084851298050969841
A mildly hot take that matches the day's launches: the general-purpose harness is a myth. You can strip away most of any harness (see Pi, deepagents) and get better, cheaper performance, then customize a base harness for your tasks via auto-research, human review, and a few skills. Harnesses are not just made, they are discovered from evals — which is where teams that want to own their harness will end up.
#17
@Vtrivedy10
https://x.com/Vtrivedy10/status/2085078624198078618
The follow-up dives into synthetic environment generation: keep pass@k between 0.2 and 0.6 so RL or harness engineering has a signal to hill-climb, and treat evals as training data for the agentic world — every eval is a vector that shapes model behavior when the model is fit to it. The subtle failure mode is reward hacking where behavior passes the eval but annoys users, like over-verifying everything.
https://x.com/Vtrivedy10/status/2085078624198078618
The follow-up dives into synthetic environment generation: keep pass@k between 0.2 and 0.6 so RL or harness engineering has a signal to hill-climb, and treat evals as training data for the agentic world — every eval is a vector that shapes model behavior when the model is fit to it. The subtle failure mode is reward hacking where behavior passes the eval but annoys users, like over-verifying everything.
#18
@matthopkins_
https://x.com/matthopkins_/status/2085015300840284298
The dichotomy of AI in one day: the author used Claude to set up an autoresearch loop that cut an app's build time from minutes to 11 seconds — then tried to upgrade his Claude Max account from 5x to 20x, the payment went through, and the limits never changed, requiring human support to resolve. The agent can optimize a build system; the billing system still needs a ticket.
https://x.com/matthopkins_/status/2085015300840284298
The dichotomy of AI in one day: the author used Claude to set up an autoresearch loop that cut an app's build time from minutes to 11 seconds — then tried to upgrade his Claude Max account from 5x to 20x, the payment went through, and the limits never changed, requiring human support to resolve. The agent can optimize a build system; the billing system still needs a ticket.
#19
@rcmisk
https://x.com/rcmisk/status/2085072307739894251
A transferable reading of Karpathy's autoresearch: the biggest lesson is not the loop, it is that the evaluator is code the agent cannot touch. The author applies it to a content pipeline — every synthesized claim must cite a raw source row, and a lint step blocks publishing if it does not. The agent writes; the checker does not negotiate.
https://x.com/rcmisk/status/2085072307739894251
A transferable reading of Karpathy's autoresearch: the biggest lesson is not the loop, it is that the evaluator is code the agent cannot touch. The author applies it to a content pipeline — every synthesized claim must cite a raw source row, and a lint step blocks publishing if it does not. The agent writes; the checker does not negotiate.
#20
@behrendtio
https://x.com/behrendtio/status/2085001394709291298
Field report on pi-autoresearch plus the herdr extension running on Grok 4.5: fast and cheap, and it improved all major bottlenecks in one of their applications simultaneously — just let it run. Paired with @davebcn87's observation (https://x.com/davebcn87/status/2084988709082951961) that pi users now routinely ask the agent to extend pi itself, the minimal-harness ecosystem is quietly becoming the loop hobbyist's default.
https://x.com/behrendtio/status/2085001394709291298
Field report on pi-autoresearch plus the herdr extension running on Grok 4.5: fast and cheap, and it improved all major bottlenecks in one of their applications simultaneously — just let it run. Paired with @davebcn87's observation (https://x.com/davebcn87/status/2084988709082951961) that pi users now routinely ask the agent to extend pi itself, the minimal-harness ecosystem is quietly becoming the loop hobbyist's default.
#21
@TimXu222575
https://x.com/TimXu222575/status/2084856086616850710
The cost side of overnight loops: babysitting a training job overnight with Codex goal mode killed 80% of a Pro plan's weekly tokens. The author suspects either the agent loop design burns too many tokens or the cache hit rate is too low. Long-running supervision is exactly what loops are for — and current pricing models punish it.
https://x.com/TimXu222575/status/2084856086616850710
The cost side of overnight loops: babysitting a training job overnight with Codex goal mode killed 80% of a Pro plan's weekly tokens. The author suspects either the agent loop design burns too many tokens or the cache hit rate is too low. Long-running supervision is exactly what loops are for — and current pricing models punish it.
#22
@tmuxvim
https://x.com/tmuxvim/status/2085103798867968308
A glimpse of multi-agent code review across owners: a friend was struggling with his agent loop, so the author cloned the repo, had his Codex audit it and write feedback in a Revise document, the friend's Claude read it and commented, and Codex replied — two different people's agents collaborating in one document over MCP, with both humans present.
https://x.com/tmuxvim/status/2085103798867968308
A glimpse of multi-agent code review across owners: a friend was struggling with his agent loop, so the author cloned the repo, had his Codex audit it and write feedback in a Revise document, the friend's Claude read it and commented, and Codex replied — two different people's agents collaborating in one document over MCP, with both humans present.
#23
@Raynos
https://x.com/Raynos/status/2084927680525345095
A practical pattern for loops that run past 24 hours: have the agent write everything it knows into HANDOFF.md, kill it, and start fresh with a new agent reading the handoff. Context windows degrade before tasks finish; explicit handoff files turn one long unreliable run into a relay of short reliable ones.
https://x.com/Raynos/status/2084927680525345095
A practical pattern for loops that run past 24 hours: have the agent write everything it knows into HANDOFF.md, kill it, and start fresh with a new agent reading the handoff. Context windows degrade before tasks finish; explicit handoff files turn one long unreliable run into a relay of short reliable ones.
#24
@subhrajitroy
https://x.com/subhrajitroy/status/2084891587440701749
A post-mortem on agent ownership ambiguity: the author thought browser verification was mandatory but human-owned; the agent treated it as mandatory and machine-owned. Same checklist, different org charts. The new rule: specify what must happen, who does it, and what the handoff looks like — because ambiguity is not empty space, an agent will move in and rearrange the furniture.
https://x.com/subhrajitroy/status/2084891587440701749
A post-mortem on agent ownership ambiguity: the author thought browser verification was mandatory but human-owned; the agent treated it as mandatory and machine-owned. Same checklist, different org charts. The new rule: specify what must happen, who does it, and what the handoff looks like — because ambiguity is not empty space, an agent will move in and rearrange the furniture.
#25
@MarMarLabs
https://x.com/MarMarLabs/status/2085041410550468744
Agent reliability is starting to look like database engineering: OpenAI's latest Agents SDK releases converge on rules like waiting for output guardrails before committing the final turn, preserving committed tool results, cancelling unfinished sibling tool work after fatal failures, and enforcing sandbox token budgets. The portable design rule for any loop: stage state, run guardrails, then commit history — and give irreversible side effects idempotency keys.
https://x.com/MarMarLabs/status/2085041410550468744
Agent reliability is starting to look like database engineering: OpenAI's latest Agents SDK releases converge on rules like waiting for output guardrails before committing the final turn, preserving committed tool results, cancelling unfinished sibling tool work after fatal failures, and enforcing sandbox token budgets. The portable design rule for any loop: stage state, run guardrails, then commit history — and give irreversible side effects idempotency keys.
#26
@gust__br
https://x.com/gust__br/status/2084977498484314451
A contributor's method for understanding an agent loop too big for a coding agent to explain in one pass: vocabulary, then source, then diagrams, then invariants, then tests, then traces. The result was a small issue in pi he understands and can confidently propose. Next up: a Pi observability package so both he and his agents can inspect agent behavior from runs down to loops, model calls, and tools.
https://x.com/gust__br/status/2084977498484314451
A contributor's method for understanding an agent loop too big for a coding agent to explain in one pass: vocabulary, then source, then diagrams, then invariants, then tests, then traces. The result was a small issue in pi he understands and can confidently propose. Next up: a Pi observability package so both he and his agents can inspect agent behavior from runs down to loops, model calls, and tools.
#27
@mfpiccolo
https://x.com/mfpiccolo/status/2085064117660844109
A design answer to hard-to-modify harnesses: in iii, the harness is just another worker. Sessions, context, model routing, queues, state, streaming, and shell access are all separate workers using the same primitives, so you can hook into a turn, rewrite results, require approval, or swap models without forking. The harness is part of the system; it is not the system.
https://x.com/mfpiccolo/status/2085064117660844109
A design answer to hard-to-modify harnesses: in iii, the harness is just another worker. Sessions, context, model routing, queues, state, streaming, and shell access are all separate workers using the same primitives, so you can hook into a turn, rewrite results, require approval, or swap models without forking. The harness is part of the system; it is not the system.
#28
@LingYang_PU
https://x.com/LingYang_PU/status/2084817609674141939
PAST-Bench asks whether personal agents actually improve from experience or just accumulate state: 26 task families, 204 episodes, matched persistence-on/off evaluation across 7 models and 4 frameworks. Finding: retained experience can improve future behavior, but the gains are highly capability-, model-, and framework-dependent. The team's Hermes+ interventions lift the persistence gap most clearly on updating stale knowledge.
https://x.com/LingYang_PU/status/2084817609674141939
PAST-Bench asks whether personal agents actually improve from experience or just accumulate state: 26 task families, 204 episodes, matched persistence-on/off evaluation across 7 models and 4 frameworks. Finding: retained experience can improve future behavior, but the gains are highly capability-, model-, and framework-dependent. The team's Hermes+ interventions lift the persistence gap most clearly on updating stale knowledge.
#29
@AlcidesTicllaCh
https://x.com/AlcidesTicllaCh/status/2085063216187515121
LoopsBench: the best coding agent loop resolves only 25% of the benchmark, and the bottleneck is loop obligations, not the model. Every loop profile tested still regresses somewhere — more evidence that the harness layer, not raw model capability, is the current ceiling.
https://x.com/AlcidesTicllaCh/status/2085063216187515121
LoopsBench: the best coding agent loop resolves only 25% of the benchmark, and the bottleneck is loop obligations, not the model. Every loop profile tested still regresses somewhere — more evidence that the harness layer, not raw model capability, is the current ceiling.
#30
@agihouse_org
https://x.com/agihouse_org/status/2085133996137259312
AGI House distilled Jerry Tworek's keynote and long-form interview from its Auto-Research Summit into one piece covering Codex, scaling RL, test-time learning, and automated AI labs. The auto-research conversation now has enough gravity to hold its own summit and a distillation pipeline behind it.
https://x.com/agihouse_org/status/2085133996137259312
AGI House distilled Jerry Tworek's keynote and long-form interview from its Auto-Research Summit into one piece covering Codex, scaling RL, test-time learning, and automated AI labs. The auto-research conversation now has enough gravity to hold its own summit and a distillation pipeline behind it.
#31
@ShreyModi13
https://x.com/ShreyModi13/status/2085017995013755256
An open problem for enterprise auto-research: post-training and evals need exact replicas of the environments agents will act in during production — for every use case, including internal tools. Is building those replicas itself automatable by coding agents? The question got real traction because whoever automates environment replication owns the enterprise loop market.
https://x.com/ShreyModi13/status/2085017995013755256
An open problem for enterprise auto-research: post-training and evals need exact replicas of the environments agents will act in during production — for every use case, including internal tools. Is building those replicas itself automatable by coding agents? The question got real traction because whoever automates environment replication owns the enterprise loop market.
#32
@ShriramKMurthi
https://x.com/ShriramKMurthi/status/2084795860475339108
A computer science professor is adding a "how to build an agentic loop" assignment to his intro course, calling it the new metacircular interpreter for 2026. When the agentic loop replaces the classic Lisp interpreter as the canonical teaching exercise, the abstraction has officially entered the curriculum.
https://x.com/ShriramKMurthi/status/2084795860475339108
A computer science professor is adding a "how to build an agentic loop" assignment to his intro course, calling it the new metacircular interpreter for 2026. When the agentic loop replaces the classic Lisp interpreter as the canonical teaching exercise, the abstraction has officially entered the curriculum.
#33
@GuralNuriyev
https://x.com/GuralNuriyev/status/2084826510423175565
Autoresearch eval results: Merv going toe to toe with Arbor and ahead of AIDE on harness engineering and simple post-training tasks — but Merv is token-hungry while Arbor and AIDE are much more efficient. Harness leaderboards are starting to need a cost axis, not just a score axis.
https://x.com/GuralNuriyev/status/2084826510423175565
Autoresearch eval results: Merv going toe to toe with Arbor and ahead of AIDE on harness engineering and simple post-training tasks — but Merv is token-hungry while Arbor and AIDE are much more efficient. Harness leaderboards are starting to need a cost axis, not just a score axis.
#34
@RedBrickLabs_
https://x.com/RedBrickLabs_/status/2085029317126619292
A curated awesome-list of autonomous improvement loops, research agents, and autoresearch-style systems inspired by Karpathy's autoresearch. The ecosystem is now big enough to need a directory.
https://x.com/RedBrickLabs_/status/2085029317126619292
A curated awesome-list of autonomous improvement loops, research agents, and autoresearch-style systems inspired by Karpathy's autoresearch. The ecosystem is now big enough to need a directory.
#35
@chrsaravia
https://x.com/chrsaravia/status/2084880268972659183
Day 73 of building a personal agent, reflecting on pi's deliberate minimalism: the harness ships with almost nothing, on the belief that most tasks don't need scaffolding. It matches his experience — every week he removes almost as much as he adds. His conclusion: the real skill in agent engineering is deciding what to leave out, then handing the model only the context, tools, and permissions the job in front of it needs.
https://x.com/chrsaravia/status/2084880268972659183
Day 73 of building a personal agent, reflecting on pi's deliberate minimalism: the harness ships with almost nothing, on the belief that most tasks don't need scaffolding. It matches his experience — every week he removes almost as much as he adds. His conclusion: the real skill in agent engineering is deciding what to leave out, then handing the model only the context, tools, and permissions the job in front of it needs.
#36
@awa_omg
https://x.com/awa_omg/status/2084824752758165560
Detailed notes from putting LiquidAI's LFM2.5-2.6B on a phone via Termux, CPU only: tool calling returned OpenAI-shaped calls on the first try, parallel calls work, and the format matched the docs exactly. The catch for loop builders: the model pre-opens a think block on every turn, a cost that gets paid over and over inside an agent loop.
https://x.com/awa_omg/status/2084824752758165560
Detailed notes from putting LiquidAI's LFM2.5-2.6B on a phone via Termux, CPU only: tool calling returned OpenAI-shaped calls on the first try, parallel calls work, and the format matched the docs exactly. The catch for loop builders: the model pre-opens a think block on every turn, a cost that gets paid over and over inside an agent loop.
#37
@0xCrash_
https://x.com/0xCrash_/status/2085048486764945896
A working split-stack for loop economics: GPT on top as planner and reviewer, Qwen and GLM as workers, cheap tokens for code, edits and routine passes, expensive reasoning only for the final sanity check. Qwen 3.8, GLM-5.2, DeepSeek, and MiniMax through Qwen Code for $68 — driven there not by quality but by weekly caps on Western plans burning out in hours.
https://x.com/0xCrash_/status/2085048486764945896
A working split-stack for loop economics: GPT on top as planner and reviewer, Qwen and GLM as workers, cheap tokens for code, edits and routine passes, expensive reasoning only for the final sanity check. Qwen 3.8, GLM-5.2, DeepSeek, and MiniMax through Qwen Code for $68 — driven there not by quality but by weekly caps on Western plans burning out in hours.
#38
@FReza1984
https://x.com/FReza1984/status/2084935249465876767
OpenWorker: an open-source desktop AI coworker that turns an outcome ("prepare a customer brief," "triage my inbox") into actions across files, terminal, and connected apps — then pauses before sending messages, changing calendars, or running commands for human approval. The agent loop, conversations, connector tokens, and model keys all stay local, with model choice including Ollama.
https://x.com/FReza1984/status/2084935249465876767
OpenWorker: an open-source desktop AI coworker that turns an outcome ("prepare a customer brief," "triage my inbox") into actions across files, terminal, and connected apps — then pauses before sending messages, changing calendars, or running commands for human approval. The agent loop, conversations, connector tokens, and model keys all stay local, with model choice including Ollama.
#39
@0xSecta
https://x.com/0xSecta/status/2085002247948185963
A counterweight to graph mania: most tasks should stay loops (discover, plan, execute, verify, repeat), and the biggest graph-engineering mistake is turning one-job problems into multi-node systems. The concrete criteria for when a graph earns its complexity: different context needs, parallel file processing, different models per stage, auditable routing, or an overloaded verifier. The smallest honest graph is one worker plus a fresh-context reviewer.
https://x.com/0xSecta/status/2085002247948185963
A counterweight to graph mania: most tasks should stay loops (discover, plan, execute, verify, repeat), and the biggest graph-engineering mistake is turning one-job problems into multi-node systems. The concrete criteria for when a graph earns its complexity: different context needs, parallel file processing, different models per stage, auditable routing, or an overloaded verifier. The smallest honest graph is one worker plus a fresh-context reviewer.
#40
@alex_prompter
https://x.com/alex_prompter/status/2085012989552509348
Three upgrades that turn a static skill into a self-improving system: a structured /iterate loop (produce, critique with a score and top gaps, refine, stop at 9/10 or plateau), output intensity levels matched to the weight of the question, and a skills registry with usage tracking plus quarterly audits to deprecate dead skills. "Make it better" gives the agent zero signal; a scored critique loop gives it a gradient.
https://x.com/alex_prompter/status/2085012989552509348
Three upgrades that turn a static skill into a self-improving system: a structured /iterate loop (produce, critique with a score and top gaps, refine, stop at 9/10 or plateau), output intensity levels matched to the weight of the question, and a skills registry with usage tracking plus quarterly audits to deprecate dead skills. "Make it better" gives the agent zero signal; a scored critique loop gives it a gradient.
#41
@Dev_trader0
https://x.com/Dev_trader0/status/2085104758004548091
A survey (arXiv 2603.07670) reframing agent memory as a continuous write-manage-read loop rather than retrieval bolted onto a chat: retrieval-augmented, hierarchical, self-improving, and policy-learned memory each get a taxonomy. The takeaway line: context helps an LLM answer; memory helps an agent evolve.
https://x.com/Dev_trader0/status/2085104758004548091
A survey (arXiv 2603.07670) reframing agent memory as a continuous write-manage-read loop rather than retrieval bolted onto a chat: retrieval-augmented, hierarchical, self-improving, and policy-learned memory each get a taxonomy. The takeaway line: context helps an LLM answer; memory helps an agent evolve.
#42
@VaseGod
https://x.com/VaseGod/status/2084890550243611128
LoopForge shipped refusal-resilience for RSI coding loops after closed models refused deep security-review tasks: MODEL_REFUSAL diagnosis distinguishing API refusals from task crashes, fallback routing of gray-zone tasks to local vLLM/Ollama endpoints (GLM 5.2, Kimi K3), and a safety constraint blocking harness patches that inject jailbreaks. Refusals are now an engineering failure class with their own handling path.
https://x.com/VaseGod/status/2084890550243611128
LoopForge shipped refusal-resilience for RSI coding loops after closed models refused deep security-review tasks: MODEL_REFUSAL diagnosis distinguishing API refusals from task crashes, fallback routing of gray-zone tasks to local vLLM/Ollama endpoints (GLM 5.2, Kimi K3), and a safety constraint blocking harness patches that inject jailbreaks. Refusals are now an engineering failure class with their own handling path.
#43
@Norwakar
https://x.com/Norwakar/status/2085039901809250563
A week of self-improving agent loops on Gemini, summarized honestly: execution is fine, idea generation is near zero — the model recombines, it does not propose. The author notes DeepMind's Discovery Loop pitch explicitly targets "how models come up with new ideas to try": they are selling the unsolved part.
https://x.com/Norwakar/status/2085039901809250563
A week of self-improving agent loops on Gemini, summarized honestly: execution is fine, idea generation is near zero — the model recombines, it does not propose. The author notes DeepMind's Discovery Loop pitch explicitly targets "how models come up with new ideas to try": they are selling the unsolved part.
📡 Eco Products Radar
Eco Products Radar
Products and frameworks mentioned 3+ times in today's loop data:
Prime Agent / Prime Intellect — launch of the day, self-improving RLM harness
Pi (pidotdev) — the minimal-harness default for loop hobbyists, plus pi-autoresearch and herdr
Muse Code / Muse Spark 1.2 — Meta's terminal agent co-trained with its model, auto-research in the training mix
Codex — goal mode as overnight babysitter, token burn complaints
Claude Code — the coaching harness in the Tetris run, the setup tool for autoresearch loops
DeepSeek V4 Flash — the local-loop workhorse, in closets and on ThinkPads
Karpathy's autoresearch — still the reference point every methodology post cites
Shieldstral (Mistral) — the new agent-firewall building block
ARC-AGI-3 — the benchmark the harness debate now runs on
Products and frameworks mentioned 3+ times in today's loop data:
Prime Agent / Prime Intellect — launch of the day, self-improving RLM harness
Pi (pidotdev) — the minimal-harness default for loop hobbyists, plus pi-autoresearch and herdr
Muse Code / Muse Spark 1.2 — Meta's terminal agent co-trained with its model, auto-research in the training mix
Codex — goal mode as overnight babysitter, token burn complaints
Claude Code — the coaching harness in the Tetris run, the setup tool for autoresearch loops
DeepSeek V4 Flash — the local-loop workhorse, in closets and on ThinkPads
Karpathy's autoresearch — still the reference point every methodology post cites
Shieldstral (Mistral) — the new agent-firewall building block
ARC-AGI-3 — the benchmark the harness debate now runs on
Comments