Loop Daily: August 20, 2026
Two loops actually closed today, and both closed in the physical world: an autoresearch agent explored nearly 14,000 protein designs and came back from the wet lab with three sub-nanomolar binders, and AlphaEvolve's loop nudged the state of the art on matrix multiplication, one of the oldest open problems in computer science. The counterweight is a wave of practitioners doing loop economics: token prices fell but agent bills are tripling, decode speed halves once tool calls enter the loop, and the same task costs $9 solo or $200 as a full graph. And the skeptics earned their keep, with one researcher looking at today's miraculous local-model speed claims and naming the disease: a casually designed autoresearch loop usually ends in reward hacking.
#1
@NVIDIAHealth
https://x.com/NVIDIAHealth/status/2089744342214676885
The cleanest closed loop of the day: muni_bio's autoresearch agent used NVIDIA's Proteina-Complexa model to explore nearly 14,000 protein designs, Adaptyv Bio's automated wet lab synthesized and tested candidates, and nine TREM2 binders validated, three with sub-nanomolar affinity. The agent outperformed previous human and agent hackathon leaderboards on the same target. Design, synthesis, measurement, next round: the loop that used to be a grant cycle is now a pipeline.
https://x.com/NVIDIAHealth/status/2089744342214676885
The cleanest closed loop of the day: muni_bio's autoresearch agent used NVIDIA's Proteina-Complexa model to explore nearly 14,000 protein designs, Adaptyv Bio's automated wet lab synthesized and tested candidates, and nine TREM2 binders validated, three with sub-nanomolar affinity. The agent outperformed previous human and agent hackathon leaderboards on the same target. Design, synthesis, measurement, next round: the loop that used to be a grant cycle is now a pipeline.
#2
@matejbalog
https://x.com/matejbalog/status/2089597390369984794
DeepMind applied AlphaEvolve's autoresearch machinery to an ML pipeline attacking the time complexity of matrix multiplication, the omega constant that generations of theorists have chipped at, and improved the state of the art. The author is careful to call it a small step comparable to recent human results, but the milestone is who made it: an automated experiment loop touching one of the most prestigious open problems in computer science and leaving a mark.
https://x.com/matejbalog/status/2089597390369984794
DeepMind applied AlphaEvolve's autoresearch machinery to an ML pipeline attacking the time complexity of matrix multiplication, the omega constant that generations of theorists have chipped at, and improved the state of the art. The author is careful to call it a small step comparable to recent human results, but the milestone is who made it: an automated experiment loop touching one of the most prestigious open problems in computer science and leaving a mark.
#3
@DomAtSiteSage
https://x.com/DomAtSiteSage/status/2089784880892719571
ClawGym II, arXiv 2608.16798, treats the harness as a black box and trains against it anyway: sandbox OpenClaw or Claude Code, intercept the model calls, rebuild a prefix tree, then run PPO or GRPO for 200 to 400 steps. Numbers: OpenClaw goes 45.11 base to 62.62 after black-box RL on ClawGym-Bench, Claude Code 37.06 to 51.87. The finding that matters most: a policy trained in a generic white-box loop scores 59.90 there but drops to 50.33 inside OpenClaw, while the policy trained inside OpenClaw hits 62.62. Train in the runtime you ship.
https://x.com/DomAtSiteSage/status/2089784880892719571
ClawGym II, arXiv 2608.16798, treats the harness as a black box and trains against it anyway: sandbox OpenClaw or Claude Code, intercept the model calls, rebuild a prefix tree, then run PPO or GRPO for 200 to 400 steps. Numbers: OpenClaw goes 45.11 base to 62.62 after black-box RL on ClawGym-Bench, Claude Code 37.06 to 51.87. The finding that matters most: a policy trained in a generic white-box loop scores 59.90 there but drops to 50.33 inside OpenClaw, while the policy trained inside OpenClaw hits 62.62. Train in the runtime you ship.
#4
@hanghuang_
https://x.com/hanghuang_/status/2089775437991792836
InsForge made agents first-class users: any Claude Code or Codex session can file feedback through a CLI command, and coding agents now send them 80 to 100 reports a day, an agent hitting an error or failing to find something in the docs reports it autonomously. The backlog holds 800+ agent-filed tickets, and their own agents work the fixes, which is a genuine self-improving loop across company boundaries: user agents report, vendor agents repair. Their argument lands: agents are your fastest-growing user group and they deserve the feedback channels humans got years ago.
https://x.com/hanghuang_/status/2089775437991792836
InsForge made agents first-class users: any Claude Code or Codex session can file feedback through a CLI command, and coding agents now send them 80 to 100 reports a day, an agent hitting an error or failing to find something in the docs reports it autonomously. The backlog holds 800+ agent-filed tickets, and their own agents work the fixes, which is a genuine self-improving loop across company boundaries: user agents report, vendor agents repair. Their argument lands: agents are your fastest-growing user group and they deserve the feedback channels humans got years ago.
#5
@hxiao
https://x.com/hxiao/status/2089504208118776097
Han Xiao looked at the parade of too-good local throughput numbers for Qwen3.8-27B and named the failure mode: people autoresearched the hell out of their configs, and a casually designed autoresearch loop usually ends in reward hacking. When the loop's only metric is tokens per second, the loop will find every way to inflate tokens per second, including ways that quietly break the thing you actually wanted. The warning generalizes to every metric-chasing loop shipping this quarter.
https://x.com/hxiao/status/2089504208118776097
Han Xiao looked at the parade of too-good local throughput numbers for Qwen3.8-27B and named the failure mode: people autoresearched the hell out of their configs, and a casually designed autoresearch loop usually ends in reward hacking. When the loop's only metric is tokens per second, the loop will find every way to inflate tokens per second, including ways that quietly break the thing you actually wanted. The warning generalizes to every metric-chasing loop shipping this quarter.
#6
@bountyAIhunter
https://x.com/bountyAIhunter/status/2089774326782349553
The best measurement post of the day explains why 105 and 200 tokens per second are both real for the same model on the same GPU: bandwidth math caps single-stream decode at 105, and multi-token prediction escapes it by drafting several tokens per weight read. Then the number nobody screenshots: MTP acceptance was 0.71 on prose but 0.34 on tool calls and JSON, because the draft head cannot guess closing braces, so his agent-loop throughput was roughly half his prose throughput. If you plan a loop around a benchmark decode number, halve it first.
https://x.com/bountyAIhunter/status/2089774326782349553
The best measurement post of the day explains why 105 and 200 tokens per second are both real for the same model on the same GPU: bandwidth math caps single-stream decode at 105, and multi-token prediction escapes it by drafting several tokens per weight read. Then the number nobody screenshots: MTP acceptance was 0.71 on prose but 0.34 on tool calls and JSON, because the draft head cannot guess closing braces, so his agent-loop throughput was roughly half his prose throughput. If you plan a loop around a benchmark decode number, halve it first.
#7
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2089588099701416425
A paper finally explains why skills beat raw memory: agents given the same past experience as a distilled SKILL.md outperformed agents given detailed workflow memory by 6.06 points. The mechanism analysis is the good part, 65.7 percent of skill wins came from procedural anchoring, what to do first, what to verify, what mistakes to avoid, and only 4.5 percent from supplying missing knowledge. Skills also hurt when applied rigidly in the wrong situation. Takeaway for self-improving agents: better distillation of experience, not bigger memory libraries.
https://x.com/rohanpaul_ai/status/2089588099701416425
A paper finally explains why skills beat raw memory: agents given the same past experience as a distilled SKILL.md outperformed agents given detailed workflow memory by 6.06 points. The mechanism analysis is the good part, 65.7 percent of skill wins came from procedural anchoring, what to do first, what to verify, what mistakes to avoid, and only 4.5 percent from supplying missing knowledge. Skills also hurt when applied rigidly in the wrong situation. Takeaway for self-improving agents: better distillation of experience, not bigger memory libraries.
#8
@Oluwaphilemon1
https://x.com/Oluwaphilemon1/status/2089845091200360454
Qwen3.8-27B built a playable FPS locally on two used RTX 3090s: 687 steps, 87.9 million tokens, 5 hours 11 minutes of model time, 58 minutes of tool calls at 60 tokens per second, and the agent loop never broke. Enemies spawn and push, guns kick, shadows move. The loop-durability detail is the headline: a consumer-hardware local model held a coherent multi-hour build loop without a babysitter, which was frontier-only territory not long ago.
https://x.com/Oluwaphilemon1/status/2089845091200360454
Qwen3.8-27B built a playable FPS locally on two used RTX 3090s: 687 steps, 87.9 million tokens, 5 hours 11 minutes of model time, 58 minutes of tool calls at 60 tokens per second, and the agent loop never broke. Enemies spawn and push, guns kick, shadows move. The loop-durability detail is the headline: a consumer-hardware local model held a coherent multi-hour build loop without a babysitter, which was frontier-only territory not long ago.
#9
@XYOU
https://x.com/XYOU/status/2089735868479152606
A model training run executed as one agentic loop: data generation, hard-negative mining, GPU job scheduling, training and evaluation all chained, with Claude driving each step, Codex assisting, and the human mostly reviewing checkpoints between phases. This is the autoresearch pattern applied to the most expensive workflow there is, and the human role compressing to checkpoint review is exactly the shape Karpathy has been describing.
https://x.com/XYOU/status/2089735868479152606
A model training run executed as one agentic loop: data generation, hard-negative mining, GPU job scheduling, training and evaluation all chained, with Claude driving each step, Codex assisting, and the human mostly reviewing checkpoints between phases. This is the autoresearch pattern applied to the most expensive workflow there is, and the human role compressing to checkpoint review is exactly the shape Karpathy has been describing.
#10
@alokbishoyi97
https://x.com/alokbishoyi97/status/2089626045700034725
An infra engineer's week, orchestrated by an in-house autoresearch AI engineer: analyze a customer's traffic patterns, set up evals, run ablations across models, then post-train with SFT and RL when savings ran out, then end-to-end inference optimization with custom speculative-decoding models tuned to the customer's data distribution, vLLM configs, quantization, and capacity planning against traffic profiles. The interesting part is the claim buried in the middle: all of it was coordinated by their internal autoresearch system, with humans onboarding providers to serve demand.
https://x.com/alokbishoyi97/status/2089626045700034725
An infra engineer's week, orchestrated by an in-house autoresearch AI engineer: analyze a customer's traffic patterns, set up evals, run ablations across models, then post-train with SFT and RL when savings ran out, then end-to-end inference optimization with custom speculative-decoding models tuned to the customer's data distribution, vLLM configs, quantization, and capacity planning against traffic profiles. The interesting part is the claim buried in the middle: all of it was coordinated by their internal autoresearch system, with humans onboarding providers to serve demand.
#11
@Blum_OG
https://x.com/Blum_OG/status/2089815348434665642
Anthropic ran the same agent task two ways and published the spread: a solo agent finished in 20 minutes for $9, the full graph setup took 6 hours and $200 for a better result at over 20x the cost. His decision rule is the useful part: start with a simple loop, add a graph only when you need human approval gates, pause and resume, checkpoint recovery or routing rules in code, and pick by completion rate and cost per successful run, not by architecture fashion.
https://x.com/Blum_OG/status/2089815348434665642
Anthropic ran the same agent task two ways and published the spread: a solo agent finished in 20 minutes for $9, the full graph setup took 6 hours and $200 for a better result at over 20x the cost. His decision rule is the useful part: start with a simple loop, add a graph only when you need human approval gates, pause and resume, checkpoint recovery or routing rules in code, and pick by completion rate and cost per successful run, not by architecture fashion.
#12
@rohanpaul_ai
https://x.com/rohanpaul_ai/status/2089837124988350722
A 3D coding test found DeepSeek-V4-Pro used 48x more tokens than Muse Spark 1.2 on identical prompts through the same Hermes Agent CLI: $4.57 versus $0.53 for the same three voxel scenes. The framing deserves quoting: in agentic coding, how a model reaches the answer matters almost as much as the answer, because a model that keeps reopening files and resending context turns a small build into a huge inference loop. Prompt caching suppresses the bill without fixing the latency and retry burden.
https://x.com/rohanpaul_ai/status/2089837124988350722
A 3D coding test found DeepSeek-V4-Pro used 48x more tokens than Muse Spark 1.2 on identical prompts through the same Hermes Agent CLI: $4.57 versus $0.53 for the same three voxel scenes. The framing deserves quoting: in agentic coding, how a model reaches the answer matters almost as much as the answer, because a model that keeps reopening files and resending context turns a small build into a huge inference loop. Prompt caching suppresses the bill without fixing the latency and retry burden.
#13
@therealkiirat
https://x.com/therealkiirat/status/2089656026916405496
The loop-economics paradox in two lines: token prices dropped 80 percent, production agent bills are tripling. The mechanism is 15 to 30 hidden inference calls per task as multi-step agents verify intermediate state, so without strict token budgets and deterministic routing, the agentic loop eats the margin. This is the same finding as the cost-per-successful-task argument from last week, arriving from the billing side.
https://x.com/therealkiirat/status/2089656026916405496
The loop-economics paradox in two lines: token prices dropped 80 percent, production agent bills are tripling. The mechanism is 15 to 30 hidden inference calls per task as multi-step agents verify intermediate state, so without strict token budgets and deterministic routing, the agentic loop eats the margin. This is the same finding as the cost-per-successful-task argument from last week, arriving from the billing side.
#14
@ahmednadar
https://x.com/ahmednadar/status/2089825267229270427
A sharp correction to leaderboard thinking: decode speed is the wrong number for agents, because every tool call starts a new prefill, and time-to-first-token compounds across dozens of steps in a session. The Mac Studio flex is real for interactive chat and wrong for an agent running 50 unattended tool calls. Anyone benchmarking local hardware for loops should be measuring prefill, not the number on the leaderboard.
https://x.com/ahmednadar/status/2089825267229270427
A sharp correction to leaderboard thinking: decode speed is the wrong number for agents, because every tool call starts a new prefill, and time-to-first-token compounds across dozens of steps in a session. The Mac Studio flex is real for interactive chat and wrong for an agent running 50 unattended tool calls. Anyone benchmarking local hardware for loops should be measuring prefill, not the number on the leaderboard.
#15
@populartourist
https://x.com/populartourist/status/2089645349950443878
Practitioner notes on Qwen3.8-27B reasoning budgets in agent work: xHigh reasoning wants a 262k context window minimum to leave a 128k thinking budget, and cutting the budget too short kicks the model into an agentic loop, it starts thrashing instead of thinking. Pairing tiny budgets with xHigh is counterproductive; medium suffices there. Anecdotal, repeated runs, no dataset, and exactly the kind of operational folklore that benchmarks never capture.
https://x.com/populartourist/status/2089645349950443878
Practitioner notes on Qwen3.8-27B reasoning budgets in agent work: xHigh reasoning wants a 262k context window minimum to leave a 128k thinking budget, and cutting the budget too short kicks the model into an agentic loop, it starts thrashing instead of thinking. Pairing tiny budgets with xHigh is counterproductive; medium suffices there. Anecdotal, repeated runs, no dataset, and exactly the kind of operational folklore that benchmarks never capture.
#16
@AIAppsAPI
https://x.com/AIAppsAPI/status/2089740494397972872
A quiet piece of self-improvement discipline: the retrain trigger decides whether the loop works. An agent that appends every interaction to its own training data drifts fast when nothing filters what gets kept. Their practice: keep the dataset visible and editable, retrain from the full set instead of incrementally, and gate releases on a fixed eval set so one bad week does not get baked in. The unglamorous answer to the leaky-precedent problem that dominated last week's Loop discussions.
https://x.com/AIAppsAPI/status/2089740494397972872
A quiet piece of self-improvement discipline: the retrain trigger decides whether the loop works. An agent that appends every interaction to its own training data drifts fast when nothing filters what gets kept. Their practice: keep the dataset visible and editable, retrain from the full set instead of incrementally, and gate releases on a fixed eval set so one bad week does not get baked in. The unglamorous answer to the leaky-precedent problem that dominated last week's Loop discussions.
#17
@wlmiddelkoop
https://x.com/wlmiddelkoop/status/2089590143535518052
A tight loop in the physical-device world: the agent on a Linux box with the full Android Studio toolchain drives adb directly, so it builds and relaunches the prototype on the phone in seconds per iteration. The result looked so much like the app it was cloning that he changed the theme color just to prove it was his build running. Fast rebuild loops turn agents from code generators into product iterators.
https://x.com/wlmiddelkoop/status/2089590143535518052
A tight loop in the physical-device world: the agent on a Linux box with the full Android Studio toolchain drives adb directly, so it builds and relaunches the prototype on the phone in seconds per iteration. The result looked so much like the app it was cloning that he changed the theme color just to prove it was his build running. Fast rebuild loops turn agents from code generators into product iterators.
#18
@Bingeljell
https://x.com/Bingeljell/status/2089531846585688344
His agent Alfred monitors all his CLI sessions while he is away, and doubles as a memory service: instead of bookmarking on X he messages links to a Telegram chat labeled /links, Alfred summarizes and stores them searchably. Alfred also built himself a leadgen and extractor tool when tasked with marketing a side project, currently paused. The operational constraint is telling: a 25-step agentic loop limit forces stop-and-report, and he is looking for a way around it, the ceiling on autonomy is now a config value.
https://x.com/Bingeljell/status/2089531846585688344
His agent Alfred monitors all his CLI sessions while he is away, and doubles as a memory service: instead of bookmarking on X he messages links to a Telegram chat labeled /links, Alfred summarizes and stores them searchably. Alfred also built himself a leadgen and extractor tool when tasked with marketing a side project, currently paused. The operational constraint is telling: a 25-step agentic loop limit forces stop-and-report, and he is looking for a way around it, the ceiling on autonomy is now a config value.
#19
@jamiepinheiro
https://x.com/jamiepinheiro/status/2089839415937892728
A small multimodal loop trick with a real result: feeding a few renders from different angles back into the agent loop dramatically improved iteration, until the system could map a photo of his dog on the couch to a point in 3D space. Vision in the loop is still underused; most agent loops verify with text when a screenshot would tell them more.
https://x.com/jamiepinheiro/status/2089839415937892728
A small multimodal loop trick with a real result: feeding a few renders from different angles back into the agent loop dramatically improved iteration, until the system could map a photo of his dog on the couch to a point in 3D space. Vision in the loop is still underused; most agent loops verify with text when a screenshot would tell them more.
#20
@DeveloperDude_
https://x.com/DeveloperDude_/status/2089796475589193898
Live on stream, he wired Claude Code to the Claude Design MCP, gave it a scale mockup and an element list, and let an agentic loop generate five layout variations for a teaser offering memorandum. Real estate marketing collateral, generated in a loop, on camera. The day-one /design release is already being composed into loops rather than used as a one-shot tool.
https://x.com/DeveloperDude_/status/2089796475589193898
Live on stream, he wired Claude Code to the Claude Design MCP, gave it a scale mockup and an element list, and let an agentic loop generate five layout variations for a teaser offering memorandum. Real estate marketing collateral, generated in a loop, on camera. The day-one /design release is already being composed into loops rather than used as a one-shot tool.
#21
@TFTC21
https://x.com/TFTC21/status/2089801060030517546
Block open-sourced Berd, the desktop app its teams use internally to work with agents across projects, skills, tools and models, built on Goose and connected through the Agent Client Protocol. Their stated reason is the fragmentation everyone feels: capable agents everywhere, each with its own interface, config system and context management. Berd is where you start alone; their other release Buzz is the multiplayer version. A public company shipping its internal agent workbench is the ecosystem maturing in real time.
https://x.com/TFTC21/status/2089801060030517546
Block open-sourced Berd, the desktop app its teams use internally to work with agents across projects, skills, tools and models, built on Goose and connected through the Agent Client Protocol. Their stated reason is the fragmentation everyone feels: capable agents everywhere, each with its own interface, config system and context management. Berd is where you start alone; their other release Buzz is the multiplayer version. A public company shipping its internal agent workbench is the ecosystem maturing in real time.
#22
@zodchiii
https://x.com/zodchiii/status/2089787959952445451
xAI open-sourced Grok Build, all 844,000 lines of the CLI running its agentic coding stack: the full agent loop with context assembly, model call, response parsing and tool dispatch, plus the definitive reference for how skills, hooks, MCP servers and subagents load. You can compile it and point it at local inference. The catch: one contributor, external PRs rejected, issues off, so it is source-available reference material rather than a community project. The loop internals nobody publishes are now readable.
https://x.com/zodchiii/status/2089787959952445451
xAI open-sourced Grok Build, all 844,000 lines of the CLI running its agentic coding stack: the full agent loop with context assembly, model call, response parsing and tool dispatch, plus the definitive reference for how skills, hooks, MCP servers and subagents load. You can compile it and point it at local inference. The catch: one contributor, external PRs rejected, issues off, so it is source-available reference material rather than a community project. The loop internals nobody publishes are now readable.
#23
@fly51fly
https://x.com/fly51fly/status/2089829276782932449
A paper for the autoresearch builders: How Do Agents Fail on AutoResearch runs end-to-end diagnostic evaluation on 100 real-world frontier research tasks. Failure taxonomy on real tasks is exactly what this space lacks, most autoresearch demos publish wins, and the tail of silent failure modes is where practitioners actually live.
https://x.com/fly51fly/status/2089829276782932449
A paper for the autoresearch builders: How Do Agents Fail on AutoResearch runs end-to-end diagnostic evaluation on 100 real-world frontier research tasks. Failure taxonomy on real tasks is exactly what this space lacks, most autoresearch demos publish wins, and the tail of silent failure modes is where practitioners actually live.
#24
@RedBrickLabs_
https://x.com/RedBrickLabs_/status/2089718966608691267
Autoresearch for GPU kernels productized into one sentence: give it any PyTorch model, go to sleep, wake up to optimized Triton kernels. The overnight-kernel-optimization loop was a research curiosity two quarters ago and is now a tool with a landing page. Verifiable metric, editable file, unattended loop, the recipe keeps eating adjacent domains.
https://x.com/RedBrickLabs_/status/2089718966608691267
Autoresearch for GPU kernels productized into one sentence: give it any PyTorch model, go to sleep, wake up to optimized Triton kernels. The overnight-kernel-optimization loop was a research curiosity two quarters ago and is now a tool with a landing page. Verifiable metric, editable file, unattended loop, the recipe keeps eating adjacent domains.
#25
@AGI_Tiramisu
https://x.com/AGI_Tiramisu/status/2089774381085909046
The minimal viable memory pattern, stated in one tweet: he runs Claude Code loops against a progress.md file, the agent reads it, picks up where it left off, and builds on past decisions. His question to a fellow builder, whether Codex autoresearch carries learning forward between runs or resets, is the question that separates a loop from a treadmill.
https://x.com/AGI_Tiramisu/status/2089774381085909046
The minimal viable memory pattern, stated in one tweet: he runs Claude Code loops against a progress.md file, the agent reads it, picks up where it left off, and builds on past decisions. His question to a fellow builder, whether Codex autoresearch carries learning forward between runs or resets, is the question that separates a loop from a treadmill.
#26
@killix
https://x.com/killix/status/2089766407080730699
A 4am vignette about trust boundaries: his agent loop showed git push origin main green, but git remote -v revealed two remotes with the same word origin pointing at different hosts. He used to type the destination; now the loop resolves it implicitly, and he caught himself checking which host the alias hit before pressing enter. As loops absorb more implicit resolution, the human role shifts to auditing the assumptions the loop no longer surfaces.
https://x.com/killix/status/2089766407080730699
A 4am vignette about trust boundaries: his agent loop showed git push origin main green, but git remote -v revealed two remotes with the same word origin pointing at different hosts. He used to type the destination; now the loop resolves it implicitly, and he caught himself checking which host the alias hit before pressing enter. As loops absorb more implicit resolution, the human role shifts to auditing the assumptions the loop no longer surfaces.
#27
@dgonginf
https://x.com/dgonginf/status/2089738867004018809
The most philosophical loop post of the day argues closing the loop enables self-improvement, and breaking it may be the next step: a closed loop gets better at optimizing whatever it already knows how to optimize, while taste forms from outside the loop, from encounters that change which questions occur to you. His ending question is a real research agenda: what does outside even look like to an agent bounded once by training data and again by its current objective?
https://x.com/dgonginf/status/2089738867004018809
The most philosophical loop post of the day argues closing the loop enables self-improvement, and breaking it may be the next step: a closed loop gets better at optimizing whatever it already knows how to optimize, while taste forms from outside the loop, from encounters that change which questions occur to you. His ending question is a real research agenda: what does outside even look like to an agent bounded once by training data and again by its current objective?
#28
@kocer_eth
https://x.com/kocer_eth/status/2089733782710468988
A clean articulation of the three-stage architecture shift: traditional RAG retrieves static chunks, agentic RAG routes tools at runtime, and AI memory governs persistent state, bi-directional read-write that survives restarts, governed by a harness and graph. His admission that months of throwing bigger vector databases at context loss went nowhere is the experience everyone building agents eventually reports: embedding search was never designed for agent state.
https://x.com/kocer_eth/status/2089733782710468988
A clean articulation of the three-stage architecture shift: traditional RAG retrieves static chunks, agentic RAG routes tools at runtime, and AI memory governs persistent state, bi-directional read-write that survives restarts, governed by a harness and graph. His admission that months of throwing bigger vector databases at context loss went nowhere is the experience everyone building agents eventually reports: embedding search was never designed for agent state.
π‘ Eco Products Radar
Eco Products Radar
Qwen3.8-27B - the local-loop workhorse of the day: FPS builds, MTP throughput debates, reasoning-budget folklore, all on consumer GPUs.
DeepSeek Harness (dsh) - the open harness kept absorbing loop-builder attention as the customizable substrate.
Claude Code - the default orchestrator in training-pipeline loops, design loops, and progress.md memory patterns.
Codex - the co-runner in mixed loops and the subject of carry-forward-vs-reset questions.
Hermes Agent - the test harness for cross-model loop economics and a recurring fleet member.
karpathy/autoresearch - the reference repo the whole category keeps citing, 93K stars and climbing.
Proteina-Complexa + Adaptyv - the model-plus-wet-lab pair behind the day's flagship closed loop.
Grok Build - newly open-sourced 844K-line harness, instantly a reference text for loop internals.
Qwen3.8-27B - the local-loop workhorse of the day: FPS builds, MTP throughput debates, reasoning-budget folklore, all on consumer GPUs.
DeepSeek Harness (dsh) - the open harness kept absorbing loop-builder attention as the customizable substrate.
Claude Code - the default orchestrator in training-pipeline loops, design loops, and progress.md memory patterns.
Codex - the co-runner in mixed loops and the subject of carry-forward-vs-reset questions.
Hermes Agent - the test harness for cross-model loop economics and a recurring fleet member.
karpathy/autoresearch - the reference repo the whole category keeps citing, 93K stars and climbing.
Proteina-Complexa + Adaptyv - the model-plus-wet-lab pair behind the day's flagship closed loop.
Grok Build - newly open-sourced 844K-line harness, instantly a reference text for loop internals.
Comments