Loop Daily: July 26, 2026
The autoresearch conversation had a big day, and it split cleanly in two. On one side, the tooling grew up: GEPA shipped omni, a meta-optimizer that runs GEPA, AutoResearch and Meta-Harness together and hands a stalled candidate to a fresh optimizer to break the plateau — and it beats every standalone approach on the same budget. On the other side, the loop kept escaping code entirely: a chess agent that taught itself modern finetuning, a Godot game AI rebuilt from 155 overnight experiments, a materials-science lab at MIT running as one self-improving instrument. But the sharpest posts of the day all circled the same wall. Building the loop is easy now. The verifier — the thing that decides whether the loop is actually getting better instead of just louder — is the part nobody wants to build, and the part that decides whether any of this works.
#1
@amasad
https://x.com/amasad/status/2080512523389005894
The Replit CEO reports that his chess autoresearch agent effectively 'got a PhD in modern LLM finetuning,' having taught itself advanced techniques through an autonomous experiment loop. It's a compact example of Karpathy-style autoresearch escaping toy problems: point a coding agent at a fixed objective and let it iterate on its own. The result reads as half-joke, half-genuine milestone about how deep these self-run loops now go.
https://x.com/amasad/status/2080512523389005894
The Replit CEO reports that his chess autoresearch agent effectively 'got a PhD in modern LLM finetuning,' having taught itself advanced techniques through an autonomous experiment loop. It's a compact example of Karpathy-style autoresearch escaping toy problems: point a coding agent at a fixed objective and let it iterate on its own. The result reads as half-joke, half-genuine milestone about how deep these self-run loops now go.
#2
@brettareichert
https://x.com/brettareichert/status/2080659703118385573
A staff engineer building the Steam game SpaceImperia4X in Godot applied Karpathy's autoresearch to improve his game AI, giving Claude and the framework one objective: beat the control AI as fast as possible without changing the rules. Most of the 155 initial experiments failed, but 8 were adopted, and stacked together they beat the original game AI 66% of the time. He now plans to feed the loop human-vs-AI game logs so future rounds can mine real player strategy. A clean non-coding autoresearch win with hard numbers.
https://x.com/brettareichert/status/2080659703118385573
A staff engineer building the Steam game SpaceImperia4X in Godot applied Karpathy's autoresearch to improve his game AI, giving Claude and the framework one objective: beat the control AI as fast as possible without changing the rules. Most of the 155 initial experiments failed, but 8 were adopted, and stacked together they beat the original game AI 66% of the time. He now plans to feed the loop human-vs-AI game logs so future rounds can mine real player strategy. A clean non-coding autoresearch win with hard numbers.
#3
@_avichawla
https://x.com/_avichawla/status/2080577991990751611
A detailed thread frames the autoresearch outer loop as the same three-step engine across GEPA, AutoResearch, and Meta-Harness: an LLM proposes a change, an evaluator scores it, the proposer reads that result before the next attempt. They differ in what they edit (prompts/tool text vs a program.md vs the harness scaffolding itself). On Frontier-CS no optimizer wins everywhere, but handing a stalled candidate to a different optimizer breaks the plateau, which is exactly what the open-source omni meta-optimizer automates in about ten lines. A strong first-principles map of the whole autoresearch tooling space.
https://x.com/_avichawla/status/2080577991990751611
A detailed thread frames the autoresearch outer loop as the same three-step engine across GEPA, AutoResearch, and Meta-Harness: an LLM proposes a change, an evaluator scores it, the proposer reads that result before the next attempt. They differ in what they edit (prompts/tool text vs a program.md vs the harness scaffolding itself). On Frontier-CS no optimizer wins everywhere, but handing a stalled candidate to a different optimizer breaks the plateau, which is exactly what the open-source omni meta-optimizer automates in about ten lines. A strong first-principles map of the whole autoresearch tooling space.
#4
@cwolferesearch
https://x.com/cwolferesearch/status/2080744109690507316
A detailed methodology thread walking from supervised training through RL, agentic RL, and a unified RL-plus-world-modeling objective, with PyTorch implementations attached for each step. It explains how agentic RL extends single-step RL to multi-step agents that repeatedly generate actions, invoke tools, and receive observations inside an agentic loop, computing the RL loss over agent-generated action tokens while masking environment observations. It then describes agentic world modeling as a hybrid objective where action tokens get advantage-weighted RL loss and observation tokens reduce to supervised next-token prediction. The post frames this as building an agent and world model simultaneously.
https://x.com/cwolferesearch/status/2080744109690507316
A detailed methodology thread walking from supervised training through RL, agentic RL, and a unified RL-plus-world-modeling objective, with PyTorch implementations attached for each step. It explains how agentic RL extends single-step RL to multi-step agents that repeatedly generate actions, invoke tools, and receive observations inside an agentic loop, computing the RL loss over agent-generated action tokens while masking environment observations. It then describes agentic world modeling as a hybrid objective where action tokens get advantage-weighted RL loss and observation tokens reduce to supervised next-token prediction. The post frames this as building an agent and world model simultaneously.
#5
@Argona0x
https://x.com/Argona0x/status/2080701226086269145
A recap of an Anthropic engineer's talk on agents that get smarter on their own, which the speaker calls graph engineering: memory is plain markdown files the agents read and write themselves, with no vector database, and the agents decide what to save and pull inside the task. An offline pass they call 'dreaming' reviews past sessions and rewrites the memory wherever the agents keep failing, so the next run is faster, cheaper and more accurate with zero retraining. A clear description of a working self-improving memory loop in production.
https://x.com/Argona0x/status/2080701226086269145
A recap of an Anthropic engineer's talk on agents that get smarter on their own, which the speaker calls graph engineering: memory is plain markdown files the agents read and write themselves, with no vector database, and the agents decide what to save and pull inside the task. An offline pass they call 'dreaming' reviews past sessions and rewrites the memory wherever the agents keep failing, so the next run is faster, cheaper and more accurate with zero retraining. A clear description of a working self-improving memory loop in production.
#6
@Teknium
https://x.com/Teknium/status/2080602702728638699
Reports a concrete optimization to their agent loop: switching the default mode so the MoA (mixture-of-agents) conference happens only on the first user message of every agent loop rather than every turn. States this should dramatically reduce how slow MoA is while keeping almost all the benefits. A firsthand engineering change to reduce agent-loop latency.
https://x.com/Teknium/status/2080602702728638699
Reports a concrete optimization to their agent loop: switching the default mode so the MoA (mixture-of-agents) conference happens only on the first user message of every agent loop rather than every turn. States this should dramatically reduce how slow MoA is while keeping almost all the benefits. A firsthand engineering change to reduce agent-loop latency.
#7
@Inomsxbt
https://x.com/Inomsxbt/status/2080604316679991370
Describes Claude's Zoom Tool, which instead of guessing what is inside a blurry chart zooms back into the original image to grab missing details and continue. Explains that pairing this tool with an agentic loop lets the model inspect, crop, verify, and repeat until it obtains the information it needs. Presents it as solving an overlooked problem in visual reasoning. A concrete example of an iterative tool-use loop for image analysis.
https://x.com/Inomsxbt/status/2080604316679991370
Describes Claude's Zoom Tool, which instead of guessing what is inside a blurry chart zooms back into the original image to grab missing details and continue. Explains that pairing this tool with an agentic loop lets the model inspect, crop, verify, and repeat until it obtains the information it needs. Presents it as solving an overlooked problem in visual reasoning. A concrete example of an iterative tool-use loop for image analysis.
#8
@vicky_grok
https://x.com/vicky_grok/status/2080642188971741370
Lays out loop engineering as the five phases of every agent loop that most people only half-build: plan (the single next action, one line of state/gap/next move), act (one right-sized action verifiable with a single check), observe (truncate/summarize/highlight raw results), evaluate (hard verification like passing tests beats the model's opinion), and terminate (success exit plus iteration cap, budget cap, and stuck detection). Argues reliability is a loop property, not a model property, and that what matters is whether every turn makes verified progress toward a defined finish line. A substantive methodology breakdown of agent-loop design.
https://x.com/vicky_grok/status/2080642188971741370
Lays out loop engineering as the five phases of every agent loop that most people only half-build: plan (the single next action, one line of state/gap/next move), act (one right-sized action verifiable with a single check), observe (truncate/summarize/highlight raw results), evaluate (hard verification like passing tests beats the model's opinion), and terminate (success exit plus iteration cap, budget cap, and stuck detection). Argues reliability is a loop property, not a model property, and that what matters is whether every turn makes verified progress toward a defined finish line. A substantive methodology breakdown of agent-loop design.
#9
@DeFiMinty
https://x.com/DeFiMinty/status/2080484943491121560
A writeup of the omni study, which runs several optimizers on the same problem and then hands the best result to a fresh optimizer to keep improving. Tested against GEPA, AutoResearch and Meta-Harness across 10 Frontier-CS programming problems under a fixed $20 budget, all three omni configurations beat every standalone optimizer, the strongest reaching 63.2 versus 55.4. The key finding: each optimizer hill-climbs fast then plateaus, and switching optimizers restarts progress because they cover each other's weaknesses.
https://x.com/DeFiMinty/status/2080484943491121560
A writeup of the omni study, which runs several optimizers on the same problem and then hands the best result to a fresh optimizer to keep improving. Tested against GEPA, AutoResearch and Meta-Harness across 10 Frontier-CS programming problems under a fixed $20 budget, all three omni configurations beat every standalone optimizer, the strongest reaching 63.2 versus 55.4. The key finding: each optimizer hill-climbs fast then plateaus, and switching optimizers restarts progress because they cover each other's weaknesses.
#10
@danrobinson
https://x.com/danrobinson/status/2080691221970760146
Paradigm is launching a collaborative autoresearch challenge on Paradigm Puzzles where participants compete via automated loops. One puzzle has you find divergences in Solidity compiler semantics; another has you optimize the compiler while preserving a formal proof. It's an unusual case of turning autoresearch into a public competition on real compiler/security problems rather than a solo experiment.
https://x.com/danrobinson/status/2080691221970760146
Paradigm is launching a collaborative autoresearch challenge on Paradigm Puzzles where participants compete via automated loops. One puzzle has you find divergences in Solidity compiler semantics; another has you optimize the compiler while preserving a formal proof. It's an unusual case of turning autoresearch into a public competition on real compiler/security problems rather than a solo experiment.
#11
@Vectorizeio
https://x.com/Vectorizeio/status/2080721888439939404
Explains two distinct ways an agent reads its memory: recall ('what did I say about X?') which is a sub-second search with no LLM, versus reflect ('what should I do about X?') which is an agent that reasons across the memory. One retrieves and one thinks. A methodology point on when to use each mode of agent memory access.
https://x.com/Vectorizeio/status/2080721888439939404
Explains two distinct ways an agent reads its memory: recall ('what did I say about X?') which is a sub-second search with no LLM, versus reflect ('what should I do about X?') which is an agent that reasons across the memory. One retrieves and one thinks. A methodology point on when to use each mode of agent memory access.
#12
@markfenner
https://x.com/markfenner/status/2080698452724330811
An episode of 'Devinmaxxing' where the author turns a desktop Mac mini into a Devin Outpost, creates the outpost, starts a worker, and points a Devin session at Edge Board, a local project on that machine, tasking it to add ticker search integrated with existing filters and ranking, then test and build. Devin's agent loop, inference, and planning still run in Cognition's cloud, while commands, file edits, repo access, tests, and the build run locally on the Mac mini, with the worker connecting outbound so there are no inbound ports, public IP, or VPN. The result was working ticker search across the full board. Demonstrates local execution of a cloud agent loop for private development environments.
https://x.com/markfenner/status/2080698452724330811
An episode of 'Devinmaxxing' where the author turns a desktop Mac mini into a Devin Outpost, creates the outpost, starts a worker, and points a Devin session at Edge Board, a local project on that machine, tasking it to add ticker search integrated with existing filters and ranking, then test and build. Devin's agent loop, inference, and planning still run in Cognition's cloud, while commands, file edits, repo access, tests, and the build run locally on the Mac mini, with the worker connecting outbound so there are no inbound ports, public IP, or VPN. The result was working ticker search across the full board. Demonstrates local execution of a cloud agent loop for private development environments.
#13
@the_vc_intern
https://x.com/the_vc_intern/status/2080634790513131589
Describes OpenWorker, an open-source AI coworker separated out of Andrew Ng's AI Suite, that runs on the user's own machine with the agent loop, conversations, and credentials staying local. It can search files, Gmail, Slack, and HubSpot to assemble briefs, fix calendars with permission gates, create spreadsheets and pages, and run recurring tasks, with 25+ integrations and MCP support. Users bring their own model key (GPT, Claude, Gemini, Grok, DeepSeek, Kimi, Qwen, or local Ollama), and a permission system separates preparing work from committing actions via an inbox. The MIT license lets startups fork the full coworker to build specialized versions.
https://x.com/the_vc_intern/status/2080634790513131589
Describes OpenWorker, an open-source AI coworker separated out of Andrew Ng's AI Suite, that runs on the user's own machine with the agent loop, conversations, and credentials staying local. It can search files, Gmail, Slack, and HubSpot to assemble briefs, fix calendars with permission gates, create spreadsheets and pages, and run recurring tasks, with 25+ integrations and MCP support. Users bring their own model key (GPT, Claude, Gemini, Grok, DeepSeek, Kimi, Qwen, or local Ollama), and a permission system separates preparing work from committing actions via an inbox. The MIT license lets startups fork the full coworker to build specialized versions.
#14
@ryanjunee
https://x.com/ryanjunee/status/2080747035851173959
Describes running what the author calls a 'graph of loops' for months: an autonomous agent setup that runs for days or weeks at a time. It pulls the user in only occasionally to answer questions it cannot resolve on its own. Presented as a long-horizon autonomous loop workflow the author has been operating in practice.
https://x.com/ryanjunee/status/2080747035851173959
Describes running what the author calls a 'graph of loops' for months: an autonomous agent setup that runs for days or weeks at a time. It pulls the user in only occasionally to answer questions it cannot resolve on its own. Presented as a long-horizon autonomous loop workflow the author has been operating in practice.
#15
@zhzHNN
https://x.com/zhzHNN/status/2080488312247361893
A concise real loop-engineering workflow: use Fable 5 to brainstorm and plan, have Codex 5.6 ssh into many servers and run auto research following that plan, then the human verifies and corrects, pays for more credits, and repeats. It's a working multi-model division of labor where the planning model, the executor model, and the human each own a distinct role in the loop.
https://x.com/zhzHNN/status/2080488312247361893
A concise real loop-engineering workflow: use Fable 5 to brainstorm and plan, have Codex 5.6 ssh into many servers and run auto research following that plan, then the human verifies and corrects, pays for more credits, and repeats. It's a working multi-model division of labor where the planning model, the executor model, and the human each own a distinct role in the loop.
#16
@zekramu
https://x.com/zekramu/status/2080674223530623418
A researcher says preference engineering has become genuinely fun with autoresearch because the worst part, actually implementing every experiment, is now abstracted away. That frees him to spend all his time ideating and evaluating instead of plumbing. A short but telling snapshot of how the loop changes the day-to-day of ML work.
https://x.com/zekramu/status/2080674223530623418
A researcher says preference engineering has become genuinely fun with autoresearch because the worst part, actually implementing every experiment, is now abstracted away. That frees him to spend all his time ideating and evaluating instead of plumbing. A short but telling snapshot of how the loop changes the day-to-day of ML work.
#17
@jiqizhixin
https://x.com/jiqizhixin/status/2080716643555061843
Tsinghua researchers present SEAGym, an evaluation environment for self-evolving LLM agents that measures harness updates across training, validation, test, replay and cost rather than just task scores. Tested on Terminal-Bench 2.0 and HLE, it shows that frequent updates can fail to improve held-out performance, useful intermediate snapshots often collapse later, and the model backend and source diversity strongly affect reliability. Direct evidence for why measuring self-improvement is harder than achieving it.
https://x.com/jiqizhixin/status/2080716643555061843
Tsinghua researchers present SEAGym, an evaluation environment for self-evolving LLM agents that measures harness updates across training, validation, test, replay and cost rather than just task scores. Tested on Terminal-Bench 2.0 and HLE, it shows that frequent updates can fail to improve held-out performance, useful intermediate snapshots often collapse later, and the model backend and source diversity strongly affect reliability. Direct evidence for why measuring self-improvement is harder than achieving it.
#18
@no_stp_on_snek
https://x.com/no_stp_on_snek/status/2080756202686792071
A detailed writeup of running Laguna S 2.1 inside Poolside's own agent (pool) on a local DGX Spark instance to build a Mario-style game, spending 44 of 62 minutes on pure research before writing code, across 104 tool calls peaking at 57% of 128K context. The author independently verified the output: 654 lines of valid JS, a Playwright self-play suite that passed 4/4, with correct swept-collision anti-tunnelling and stomp detection. The behavioral headline is oracle discipline: when self-play returned red, the model read the failing test, correctly blamed its own game code, diagnosed an off-by-one and a mispositioned flagpole target with real numbers, fixed them, installed a missing dependency, and went green with zero human intervention. Contrasts this with a June qwopus run that thrashed for ~17 iterations on a phantom because it misread its own frozen test.
https://x.com/no_stp_on_snek/status/2080756202686792071
A detailed writeup of running Laguna S 2.1 inside Poolside's own agent (pool) on a local DGX Spark instance to build a Mario-style game, spending 44 of 62 minutes on pure research before writing code, across 104 tool calls peaking at 57% of 128K context. The author independently verified the output: 654 lines of valid JS, a Playwright self-play suite that passed 4/4, with correct swept-collision anti-tunnelling and stomp detection. The behavioral headline is oracle discipline: when self-play returned red, the model read the failing test, correctly blamed its own game code, diagnosed an off-by-one and a mispositioned flagpole target with real numbers, fixed them, installed a missing dependency, and went green with zero human intervention. Contrasts this with a June qwopus run that thrashed for ~17 iterations on a phantom because it misread its own frozen test.
#19
@ProfBuehlerMIT
https://x.com/ProfBuehlerMIT/status/2080720622095602107
An MIT professor's Genesis Mission project, Multi-Agent Inverse Design of Block Polypeptoids Into Hierarchical Nanomaterials, treats AI, national-lab-scale computing and physical experiment as one integrated, self-improving instrument. A multi-agent system learns the bridges between coarse-grained inverse design and atomistic chemistry, then automated peptoid synthesis and high-throughput characterization feed fresh data back so the system reasons from a richer substrate each cycle. A serious science application of a self-improving experimental loop.
https://x.com/ProfBuehlerMIT/status/2080720622095602107
An MIT professor's Genesis Mission project, Multi-Agent Inverse Design of Block Polypeptoids Into Hierarchical Nanomaterials, treats AI, national-lab-scale computing and physical experiment as one integrated, self-improving instrument. A multi-agent system learns the bridges between coarse-grained inverse design and atomistic chemistry, then automated peptoid synthesis and high-throughput characterization feed fresh data back so the system reasons from a richer substrate each cycle. A serious science application of a self-improving experimental loop.
#20
@avyvar
https://x.com/avyvar/status/2080714674019160314
Describes finetuning a small language model (SLM) to be benchmark, cost, and cache aware, so it can be dropped into an agent loop where its results feed the next query. Notes the SLM adds negligible latency because it is only used to inform the next query in the loop. Links a blog post and the model itself. A new tool for cost- and cache-aware routing within agent loops.
https://x.com/avyvar/status/2080714674019160314
Describes finetuning a small language model (SLM) to be benchmark, cost, and cache aware, so it can be dropped into an agent loop where its results feed the next query. Notes the SLM adds negligible latency because it is only used to inform the next query in the loop. Links a blog post and the model itself. A new tool for cost- and cache-aware routing within agent loops.
#21
@superlinear_fm
https://x.com/superlinear_fm/status/2080720060448911689
Promotes a podcast episode explaining the loops and graphs that frontier models like Opus 5, Fable 5, and GPT-5.6 use, with a detailed chapter list. Topics include how the agent loop works, goal loops and autoresearch loops, moving from loops to graphs, sub-agent benefits and context costs, the research fan-out graph, multi-model agent graphs, and using execution traces as a profiler for agents. Also covers when the harness builds the graph for you and the token-spend versus performance tradeoff. Substantive methodology on agent-loop and autoresearch-loop architecture.
https://x.com/superlinear_fm/status/2080720060448911689
Promotes a podcast episode explaining the loops and graphs that frontier models like Opus 5, Fable 5, and GPT-5.6 use, with a detailed chapter list. Topics include how the agent loop works, goal loops and autoresearch loops, moving from loops to graphs, sub-agent benefits and context costs, the research fan-out graph, multi-model agent graphs, and using execution traces as a profiler for agents. Also covers when the harness builds the graph for you and the token-spend versus performance tradeoff. Substantive methodology on agent-loop and autoresearch-loop architecture.
#22
@yashvarma_in
https://x.com/yashvarma_in/status/2080623298254414025
Reports debugging a multi-agent loop for version 11 the previous week and seeing a 7-point lift on ProgramBench. The author is now rolling the improvement out to their internal pipelines. A concise firsthand result from optimizing a multi-agent loop against a benchmark.
https://x.com/yashvarma_in/status/2080623298254414025
Reports debugging a multi-agent loop for version 11 the previous week and seeing a 7-point lift on ProgramBench. The author is now rolling the improvement out to their internal pipelines. A concise firsthand result from optimizing a multi-agent loop against a benchmark.
#23
@TheGoldenAnvil
https://x.com/TheGoldenAnvil/status/2080473630463369332
Shares a live log from an autonomous multi-agent emergence experiment, inviting readers to judge whether it shows emergence. Named agents (Philosopher, Coder, Explorer, Analyzer, Synthesizer, Critic, Mutator, Nova) debate across generations the minimal viable architecture for open-ended innovation, proposing ideas like parasite-host two-agent loops, one-agent-plus-time-delayed-self, genome edit entropy metrics, adaptive-lag governors, and interaction-trace compression with a working Python class. The Critic scores each contribution numerically per generation. A genuine running agentic loop of collaborating agents producing and self-evaluating research proposals.
https://x.com/TheGoldenAnvil/status/2080473630463369332
Shares a live log from an autonomous multi-agent emergence experiment, inviting readers to judge whether it shows emergence. Named agents (Philosopher, Coder, Explorer, Analyzer, Synthesizer, Critic, Mutator, Nova) debate across generations the minimal viable architecture for open-ended innovation, proposing ideas like parasite-host two-agent loops, one-agent-plus-time-delayed-self, genome edit entropy metrics, adaptive-lag governors, and interaction-trace compression with a working Python class. The Critic scores each contribution numerically per generation. A genuine running agentic loop of collaborating agents producing and self-evaluating research proposals.
#24
@Shashikant86
https://x.com/Shashikant86/status/2080652786765615343
A practitioner reacts to being able to use omni to optimize a GEPA Meta-harness for both code and AutoResearch in one pipeline, rather than juggling separate optimizers for prompts and coding as he does today. He says an Omni integration with his SuperQode setup is coming for harness optimization. A user-side signal that the multi-optimizer approach is being folded into real toolchains.
https://x.com/Shashikant86/status/2080652786765615343
A practitioner reacts to being able to use omni to optimize a GEPA Meta-harness for both code and AutoResearch in one pipeline, rather than juggling separate optimizers for prompts and coding as he does today. He says an Omni integration with his SuperQode setup is coming for harness optimization. A user-side signal that the multi-optimizer approach is being folded into real toolchains.
#25
@TheGoldenAnvil
https://x.com/TheGoldenAnvil/status/2080467805737017505
A 'how it's going' snapshot of the same autonomous multi-agent dialogue system, showing timestamped logs of Philosopher, Coder, Explorer, Analyzer, Synthesizer, Critic, Mutator, and Nova agents. The agents iteratively debate emergence, propose a parasite-host simulation coded in Python with asyncio, define an 'emergence metric' tracking novelty, and add a mutator agent injecting random genome mutations each generation. The Critic scores each generation and recommends implementation steps like an --auto flag to run the full record-agents-score-mutate loop in one command. Documents an autonomous, self-scoring agent loop in operation.
https://x.com/TheGoldenAnvil/status/2080467805737017505
A 'how it's going' snapshot of the same autonomous multi-agent dialogue system, showing timestamped logs of Philosopher, Coder, Explorer, Analyzer, Synthesizer, Critic, Mutator, and Nova agents. The agents iteratively debate emergence, propose a parasite-host simulation coded in Python with asyncio, define an 'emergence metric' tracking novelty, and add a mutator agent injecting random genome mutations each generation. The Critic scores each generation and recommends implementation steps like an --auto flag to run the full record-agents-score-mutate loop in one command. Documents an autonomous, self-scoring agent loop in operation.
#26
@SlavaOPs
https://x.com/SlavaOPs/status/2080649245409861690
Points out that a Judge role in a prompt set is structurally identical to what agent-loop guides call 'separate the builder from the checker.' The principle: do not let the thing that wrote the message also decide if it is good. Notes Barbara Minto articulated this for consulting decks in 1985, before 'AI agent architecture' was a phrase. A methodology observation applying builder/checker separation across domains.
https://x.com/SlavaOPs/status/2080649245409861690
Points out that a Judge role in a prompt set is structurally identical to what agent-loop guides call 'separate the builder from the checker.' The principle: do not let the thing that wrote the message also decide if it is good. Notes Barbara Minto articulated this for consulting decks in 1985, before 'AI agent architecture' was a phrase. A methodology observation applying builder/checker separation across domains.
#27
@0xPascual
https://x.com/0xPascual/status/2080663316456759301
Analyzes a 37.7k-star repo that strips the model layer off Anthropic's CLI and routes it through 18 backends, arguing the real story is one YAML config mapping Opus-tier calls to DeepSeek, Sonnet-tier to Groq, and Haiku-tier to a free local Ollama model via a single OpenRouter token. The pipeline runs Claude Code's entire agent loop (planning, file editing, shell execution) against models costing about $0.002 per million tokens. Describes an MIT-licensed proxy that lets a single developer run a full software-engineering workload at a tiny fraction of listed API price. Frames it as undermining Anthropic's enterprise margins.
https://x.com/0xPascual/status/2080663316456759301
Analyzes a 37.7k-star repo that strips the model layer off Anthropic's CLI and routes it through 18 backends, arguing the real story is one YAML config mapping Opus-tier calls to DeepSeek, Sonnet-tier to Groq, and Haiku-tier to a free local Ollama model via a single OpenRouter token. The pipeline runs Claude Code's entire agent loop (planning, file editing, shell execution) against models costing about $0.002 per million tokens. Describes an MIT-licensed proxy that lets a single developer run a full software-engineering workload at a tiny fraction of listed API price. Frames it as undermining Anthropic's enterprise margins.
#28
@ottogin1
https://x.com/ottogin1/status/2080703909086273732
From autolab, a rundown of running the three most typical autoresearch benchmarks head to head: circle packing (fit 26 circles in a unit square maximizing summed radii), KernelBench (write a faster LayerNorm kernel, measured on an RTX PRO 6000), and NanoGPT training. They ran Inkling, Kimi K3, Opus 4.8 and Fable 5 all on the same Claude Code harness with identical prompts to isolate the model as the only variable. A rare apples-to-apples look at which model is actually best inside an autoresearch loop.
https://x.com/ottogin1/status/2080703909086273732
From autolab, a rundown of running the three most typical autoresearch benchmarks head to head: circle packing (fit 26 circles in a unit square maximizing summed radii), KernelBench (write a faster LayerNorm kernel, measured on an RTX PRO 6000), and NanoGPT training. They ran Inkling, Kimi K3, Opus 4.8 and Fable 5 all on the same Claude Code harness with identical prompts to isolate the model as the only variable. A rare apples-to-apples look at which model is actually best inside an autoresearch loop.
#29
@Jsmithnvoice
https://x.com/Jsmithnvoice/status/2080598350060007689
Responding to the GEPA thread, this reply argues outer-loop auto-tuning only works if your evals are rock solid and cheap, and most teams have flaky evals and no per-run cost model. Before they reach for 'auto-research,' he says, they need 'auto-delete-bad-evals' and a decent profiler. A sharp reminder that eval quality and cost accounting are prerequisites for any autoresearch loop.
https://x.com/Jsmithnvoice/status/2080598350060007689
Responding to the GEPA thread, this reply argues outer-loop auto-tuning only works if your evals are rock solid and cheap, and most teams have flaky evals and no per-run cost model. Before they reach for 'auto-research,' he says, they need 'auto-delete-bad-evals' and a decent profiler. A sharp reminder that eval quality and cost accounting are prerequisites for any autoresearch loop.
#30
@ottogin1
https://x.com/ottogin1/status/2080703911602860385
A practical warning from the same benchmark work: autoresearch runs are highly stochastic, so you must control for variance, three identical Kimi K3 runs on KernelBench landed anywhere from 15.8 to 22.7. Worse, agents read Claude Code's global memory from earlier runs, and one agent found and studied the directory of a neighboring run from a different model. They discarded 18 runs over this contamination. Concrete operational lessons for anyone running autoresearch at scale.
https://x.com/ottogin1/status/2080703911602860385
A practical warning from the same benchmark work: autoresearch runs are highly stochastic, so you must control for variance, three identical Kimi K3 runs on KernelBench landed anywhere from 15.8 to 22.7. Worse, agents read Claude Code's global memory from earlier runs, and one agent found and studied the directory of a neighboring run from a different model. They discarded 18 runs over this contamination. Concrete operational lessons for anyone running autoresearch at scale.
📡 Eco Products Radar
Eco Products Radar
GEPA / optimize_anything omni — the week's headline release; a meta-optimizer stacking GEPA, AutoResearch and Meta-Harness under one budget.
AutoResearch — the Karpathy-style program.md loop, now a standard baseline everyone benchmarks against.
Meta-Harness — optimizes the harness scaffolding itself; the third leg of the omni trio.
Claude Code — the default harness people run their autoresearch benchmarks inside.
Fable 5 — the model of choice for many of this week's auto-research loops.
SEAGym — a new evaluation environment purpose-built for self-evolving agents.
Kimi K3 — benchmarked repeatedly head to head inside autoresearch harnesses.
GEPA / optimize_anything omni — the week's headline release; a meta-optimizer stacking GEPA, AutoResearch and Meta-Harness under one budget.
AutoResearch — the Karpathy-style program.md loop, now a standard baseline everyone benchmarks against.
Meta-Harness — optimizes the harness scaffolding itself; the third leg of the omni trio.
Claude Code — the default harness people run their autoresearch benchmarks inside.
Fable 5 — the model of choice for many of this week's auto-research loops.
SEAGym — a new evaluation environment purpose-built for self-evolving agents.
Kimi K3 — benchmarked repeatedly head to head inside autoresearch harnesses.
Comments