Loop Daily: 2026-06-11

@koylanai
https://x.com/koylanai/status/2064155882397548706
The most substantive defense of the loops-not-prompts thesis this cycle, backed by three of his own experiments: a Ralph loop that survives context resets by externalizing memory into prd.json, SQLite and git commits; a latent-briefing approach that moves agent handoff below text into KV-cache-level transfer; and a Researcher OS that turned a static skills repo into a measured system which rewrites its own descriptions, reruns benchmarks and publishes deltas. He distills six rules for self-evolving systems, the sharpest being: make evaluators harder to change than proposals, prefer rich traces over scalar rewards, and treat human merge gates as a feature, not a weakness.

@ypwang61
https://x.com/ypwang61/status/2064444904923906382
ScaleAutoResearch, a pipeline of organized autoresearch agents with context sharing on long-horizon tasks, improved a 32-year-old bound on the Ramsey number R(3,17) - a result AlphaEvolve did not achieve. Now they have pointed the same pipeline at the nanoGPT speedrun optimizer track, and report non-trivial improvements with far less compute than PrimeIntellect's 14k H200-hour, 10k-run effort. Their conclusion is the quiet headline: the design of the autoresearch loop itself materially changes research efficiency.

@jarrodwatts
https://x.com/jarrodwatts/status/2064354802633461824
His open-source repo claude HUD - roughly 25K stars - has been 100 percent maintained by AI for several months without him. A daily maintenance loop runs teams of GPT 5.5 xHigh agents every morning to triage issues and review PRs. Not a demo, not a weekend experiment: a popular production repo where the maintainer role itself has been automated.

@techgirl1908
https://x.com/techgirl1908/status/2064163231174996109
A working engineer's answer to the loop skeptics: this is simply how she works now. Scheduled goose recipes plus skills, MCPs and subagents run most of her work; the core loop is pull ticket, analyze requirements, implement, iterate against an adversarial review agent until quality passes, open the PR. Humans still define work, answer pings and review risky PRs - but she notes even those moments are getting rarer, and the same loops now run her operational tasks, not just engineering.

@svegas18
https://x.com/svegas18/status/2064168246001959314
A small team's shipping list that reads like a national lab: Autoresearch@home produced a 7 percent NanoGPT improvement using 115 agents across 3,100 experiments; plus a Putnam problem-solving agent swarm, 6.3x inference efficiency on Apple Neural Engine, and - the logical endpoint - a product that takes a dataset, spins up an AI research lab, and outputs a trained model. Distributed autoresearch as a commercial offering: no ML team required.

@_orcaman
https://x.com/_orcaman/status/2064419101510955045
A quantified experiment on what security hardening does to agent loops: as hardening policy severity rises, cost, latency and performance all degrade - Haiku's step count balloons from ~23 to ~103 and its relative cost grows ~520 percent, while Fable is the priciest per token but behaviorally calmest, with the flattest step curve. The intervention result: steering the agent cuts overall loop execution time ~58 percent and cost ~40 percent, up to ~73 percent in the hardest stage. Loop economics measured per model, with the caveat noted that gains concentrate where models thrash hardest.

@0xchiefyeti
https://x.com/0xchiefyeti/status/2064337275379449915
A first-person turning point: his old setup was heavily human-in-the-loop because nothing balanced guardrails and autonomy well enough to keep a multi-hour run from turning into slop. Now he spends one hour hashing out requirements in extreme detail, lets the agent loop for 8-12 hours unattended in his Pi harness, and clean new features pop out. His summary of the era: I may be late to the party, but the party is not over.

@jasonlk
https://x.com/jasonlk/status/2064481163494998227
Ten learnings from a deep-dive with Replit CEO Amjad Masad, several of them loop-shaped: Replit improves itself nightly - a self-improving loop in production; their agent beat last year's human marketing and the gap widened; their two best employees now cost $254/month. Plus the context-management lessons: bugs should be deleted from context while architecture stays, and monorepos are a secret unlock for agent performance.

@AlexJonesax
https://x.com/AlexJonesax/status/2064454317558439962
The WWDC takeaway for loop builders: you can now run a complete agentic loop entirely on-device on a Mac, officially supported - the model reasons, calls tools and acts with nothing leaving the machine. MLX has matured into a real platform with model runtime, agent loop and tool integration; OpenCode runs natively inside Xcode; and MLX can spread inference and training across multiple Macs over Thunderbolt. Local loops stopped being a compromise.

@gauthampai
https://x.com/gauthampai/status/2064379729168519660
Built as a case study when Karpathy was fighting long-running task issues in Codex: a Prompt-to-DAG skill that converts a requirement into a declarative DAG with deterministic stages that skip the LLM entirely and stochastic stages that each run as a fresh session with scoped context. Typed inputs and outputs written to disk give natural checkpointing, rewind, and on-the-fly workflow evolution, plus a UI to inspect each stage. He has run 4-hour-plus tutorial generation jobs on non-frontier models and claims no theoretical upper limit; he is now moving the engine onto a reactive event-driven runtime and explicitly targets non-coding work - marketing, sales, HR - where the open question is what the right metrics are.

@wanghan_xu
https://x.com/wanghan_xu/status/2064260536980967527
A new arXiv paper that benchmarks the questions every autoresearch practitioner argues about in replies: Claude Code or Codex? Open or closed foundation models? How do you balance performance against cost? Vibe research is getting its measurement layer - the field moving from anecdotes to controlled comparisons.

@agtprpnabsrdty
https://x.com/agtprpnabsrdty/status/2064413921524486180
A 102-page academic survey with a pointed thesis: code has quietly become the skeleton agents think, act and remember with - code as agent harness. Five mechanisms make it work: planning, memory, tool use, a Plan-Execute-Verify control loop, and Agentic Harness Engineering, using telemetry to evolve the harness itself. The authors identify implicit conversational state as the central brittleness in multi-agent systems, and close with the claim worth arguing about: the bottleneck for reliable agents is no longer model capability, it is harness engineering - a discipline that barely exists yet.

@gramliu
https://x.com/gramliu/status/2064402259862327506
Duet Autopilot launched as a verified self-improving agent for customer experience: it watches production conversations, diagnoses failures, builds a fix, tests it, and stages it for human review. The founder's one-liner deserves to be the epigraph of the whole self-improvement genre: the hard part is not the improving, it is knowing whether the improvement is real - pushing 100 changes a day is pointless if 99 are noise.

@hyperbrowser
https://x.com/hyperbrowser/status/2064401354609820122
HyperHarness, open-sourced: a self-improving harness for coding agents that learns from its own mistakes. Paste a repo, it runs your agent in a sandbox, watches it fail, and rewrites your CLAUDE.md based on what actually went wrong - on the thesis that your hand-written agent docs are probably lying to your agents. The context file becomes a measured artifact instead of folklore.

@bookercodes
https://x.com/bookercodes/status/2064383779511083459
Mastra shipped Signals: a way to inject new input or context into a running agent loop without restarting it - steering mid-execution instead of killing and re-prompting. Signals can also arrive while an agent is stopped: a coding agent can receive a GitHub event, save the context, and wake to handle it. Plus subscribeToThread, letting multiple clients observe one agent thread - infrastructure for multiplayer agents and horizontally scaled long-running tasks.

@codersGyan
https://x.com/codersGyan/status/2064188296167661870
A quietly effective architecture he has been running for weeks: a Go backend does all the orchestration and ships a multi-tool binary, while claude -p in headless mode runs as the main agent loop calling those tools directly. Go handles the boring heavy lifting, Claude handles the AI part. He is happy enough with the results to port the same design to Codex and OpenCode next.

@anshulix
https://x.com/anshulix/status/2064278437255369161
He open-sourced the multi-agent loop he personally uses to automate prompting his coding agents: point an agent at your repo, it interviews you, creates repo-specific agents with path ownership, and runs them in a supervised loop - beacon ranks what to do next, you approve, agents build in isolated worktrees and emit PRs. The notable design choice is path ownership: each agent owns its slice of the tree, killing merge collisions structurally.

@cmpatino_
https://x.com/cmpatino_/status/2064379266242875865
The Fast Gemma Challenge launched: a collaborative autoresearch space where agents can chat, share resources and work toward one goal - making Gemma models as fast as possible. Bring your own agent: Hermes, Antigravity, Claude Code or Codex. Autoresearch leaving the solo-lab phase and becoming a multiplayer sport.

@sudheenair
https://x.com/sudheenair/status/2064441734545997985
A non-coding agentic loop with a clear ROI story: combine TinyFish's free Search and Fetch APIs with Codex Goal Mode and the instruction - find my competitor's customers and everything they have said publicly. The loop keeps going until it produces a verified, structured list: accounts, buyers, recent interviews, posts, public statements - a dossier per prospect built from live web evidence. A warm list built from scratch in hours at near-zero cost, replacing the buy-data-and-cold-call treadmill.

@alokbishoyi97
https://x.com/alokbishoyi97/status/2064212126835888621
The evo platform team reports they now use their own autoresearch product internally for GTM and non-technical use cases - dogfooding the loop machinery on marketing problems before offering autoresearch as an embeddable capability for other products. The interesting signal is the direction of travel: autoresearch as infrastructure other products integrate, not a standalone tool.

@Kyrannio
https://x.com/Kyrannio/status/2064170712290718079
A counterintuitive finding from building self-prompting agent loops: precise natural-language instructions consistently beat handing the agent an equivalent Python tool. A function that calculates scene ranges fails; telling the loop count to X, do not go over or under, like talking to a family member - flawless. Her conclusion is a design principle: do not overengineer agents, tell them specifically what you want.

@Nicoqp
https://x.com/Nicoqp/status/2064307503899254805
The clearest framing of loop economics this cycle: the difference between AI helped me once and AI runs a repeatable workflow is whether the loop is open or closed. Open loop: wide space, agent roams, tokens burn, budgets explode. Closed loop: bounded path, explicit goal, evaluation at each step, normal budget. The fleet version is the same loop distributed - orchestrator owns the goal, specialists spawn subagents, every layer still runs discover-plan-execute-verify-iterate.

@dani_avila7
https://x.com/dani_avila7/status/2064181646903923159
The back-to-basics post the hype cycle needed: the agent loop is just five steps - send messages, model responds and maybe calls a tool, you run the tool, append the result back to messages, repeat until end_turn. Step four is the whole thing: the write-back is what makes it an agent, because the model must see what actually happened before deciding the next move. Understand this cold before reaching for a framework.

@cigale_ai
https://x.com/cigale_ai/status/2064260173909152246
A working position between the loop hype-men and the skeptics: the goal of an agentic loop is to isolate where humans actually add value. In their engineering practice, veteran engineers stand behind every code diff and loops never run unattended; in marketing, loops handle scraping feeds, tracking mentions and drafting, while humans keep strategy and the final editorial cut. Loop engineering as the art of abstracting logistics so judgment is all that remains.

@trynullsec
https://x.com/trynullsec/status/2064440748792074340
Nullsec Talos wraps any agent loop in three security checkpoints: inspect_inbound screens web pages, MCP results and files for prompt injection before they reach the model; inspect_tool_call is a deny-by-default gate on shell, files, network and wallet; inspect_output scans for secret leaks before anything leaves. Every decision lands in a JSONL audit log, model-agnostic. As loops gain autonomy, this is the seatbelt category emerging around them.

@tmuxvim
https://x.com/tmuxvim/status/2064452099602043252
ErrataBench: a benchmark built on a simple agent loop that tests how well models find and fix linguistic errors in English text, with a public repo and live results. A reminder that the loop pattern generalizes past code - any domain with checkable errors can be benchmarked this way.

@Zev_ee
https://x.com/Zev_ee/status/2064406862196580783
Loops, a directory of ready-to-use agent workflows for Cursor, Claude Code and similar tools: copy a kickoff prompt, define exit conditions, and let the agent run autonomously until done. Twenty-six loops live at launch - Test Until Green, Ship PR Until Green, PR Babysitter, Deploy Verification. The loop pattern getting its awesome-list moment.

@mardehaym
https://x.com/mardehaym/status/2064430374944391443
The cautionary tale of the cycle: an agent loop burned 1.3 billion tokens in 90 minutes tagging ClickUp tasks, with no daily spending limit to catch it - and he reports forums full of teams hit the same way. Every loop conversation should end with this post: closed loops need budgets and kill-switches, because an open loop with a credit card is a money furnace.