Loop Daily: July 13, 2026

@jamonholmgren
https://x.com/jamonholmgren/status/2076001786700394610
Dumped his entire agentic setup in one post: an AGENTS.md that works as a router, self-healing docs with greppable 7-line summaries, agents that always run the app themselves, custom linters that shell out to a cheaper LLM to actually fix problems instead of flagging them, cross-agent review with personas, agent worksheets committed with the work, and a dedicated "agent loop / night shift" skill for autonomous work. Also keeps a false-confidence test audit skill that hunts tests that don't test what you think. His point: with all this, agentic coding is a different sport from dry prompting. The post pulled 227k impressions because it is the most complete public checklist of what a production loop actually needs.

@S1r1u5_
https://x.com/S1r1u5_/status/2076041885236465941
Security company built its own agent harness because Claude Code, Codex, opencode and pi were all too generic for their security orchestration workflows. The catch with custom harnesses: they silently go stale, and reading every trace to detect degradation is a massive pain, so they dogfood the agent in their own daily coding. Then they solved the "our TUI sucks so we stopped dogfooding" problem by writing a protocol translation layer between opencode's tools and their harness — opencode's polished TUI on top, their own loop, budgeting and structured outputs underneath. Bonus: a workflow watches opencode releases and an agent ports over anything useful automatically.

@Zyron5m
https://x.com/Zyron5m/status/2075929585737224522
Recap of Karpathy's new No Priors interview with the detail that matters for loop people: he let an autoresearch loop run overnight on a repo he had hand-tuned for twenty years, and it came back with a forgotten weight decay and untuned Adam betas. Twenty years of experience slept through what the loop found in one night. His honest caveat is also quoted: no objective metric, no loop. He says he has not typed a line of code since December and spends 16 hours a day expressing intent to agents.

@0xMortyx
https://x.com/0xMortyx/status/2075928768368025702
Points to Professor Ross Mike's 20-minute session on an agentic loop that costs $1.3M a month in tokens, under the thesis that agentic loops are burning money and nobody talks about it. The breakdown covers his exact setup: agent loop plus code review harness plus feedback scoring, and — the part most loop content skips — when to pull the plug. Rare honest accounting in a genre that usually only shows the wins.

@Kautukkundan
https://x.com/Kautukkundan/status/2075859396811444582
Why local agents don't make sense yet, from someone running an Apple platforms team: an agentic loop drops 20% battery in 15 minutes because macOS QoS scheduling is built for bursty apps that race to sleep, and a think-tool-wait loop never wraps up. The real cost is memory, not math — moving a byte out of DRAM costs ~1000x the arithmetic on it, roughly 2 joules per token on a 7B model, a physics floor no compute optimization gets under. The scheduler sees a hot process, ramps clocks it can't use, heat throttles the chip, cascade. Only lever: smaller models and different access patterns.

@bingxu_
https://x.com/bingxu_/status/2075961458484281497
int21 is attacking self-improvement at the infrastructure layer instead of training models: a cloud-native SwarmOS for autonomous agent systems, an architecture designed for self-improving and self-evolving agents, and a cross-session knowledge forge powered by compute. Interesting as a bet that the loop's compounding lives in shared infrastructure, not in any single model's weights.

@peteferr
https://x.com/peteferr/status/2075919589989392457
Sharpest one-paragraph definition of enterprise self-improvement this week: the improvement signal is a human correcting the agent under real conditions, and most systems log the correction and call it learning — that's an audit trail, not learning. Compounding only starts when you capture why the operator overrode the agent and feed the reasoning back, so the next decision starts from what your best human just taught it.

@YassineLanda
https://x.com/YassineLanda/status/2075926065302630542
Loom lets you type "forecast 15min bitcoin" or "who is most likely to churn" and gets to SOTA results with rigorous backtests and reproducibility in 10-15 minutes, using an RL model trained on autoresearch traces from different use cases. Ships with collaborative run sharing, remote GPU execution, mobile/desktop/web apps, data-lake support and one-click deploy. Private beta for devs and data scientists this summer. Autoresearch traces as RL training data is the notable move here.

@dilika
https://x.com/dilika/status/2075925619745927426
The pricing inversion nobody budgets for: raw LLM API calls run $2-7 per 1M tokens, coding-agent subscriptions convert to roughly $0.08-2 per 1M — the subscription is subsidizing inference. Popiol's approach: instead of calling an LLM API inside your agent, shell out to the claude binary via subprocess with --print and JSON schema output, wrap it in a LangChain-compatible adapter, and your agent loop runs on a $20/month subscription instead of an API bill. The complex agent is literally cheaper than the raw model.

@V8X_Team
https://x.com/V8X_Team/status/2076066812458885461
A team building agents spent months actually working with OpenClaw, OpenAI's Agents SDK, Google's ADK and Letta before settling on Hermes, and wrote up what they learned. Useful because every framework looks great on the landing page and almost nobody publishes the elimination reasoning — this is the "we ran the bake-off so you don't have to" genre the agent-framework market badly needs.

@VukRosic99
https://x.com/VukRosic99/status/2075929097310761121
Clean explainer of the Red Queen Gödel Machine: most self-improving agents are graded by a judge that never changes, RQGM lets the judge evolve too. Mechanics: the judge is frozen within each epoch, a new judge only takes over if it beats the old one on held-out ground truth, and swapping a judge selectively erases only the scores that depended on it. The evaluator-evolution problem is quietly becoming the frontier of loop design.

@BryceDelRio
https://x.com/BryceDelRio/status/2075761164298907756
Spent the better part of a year perfecting Claude workflows — claude.md, system prompts for subagents dispatched from a taskboard, a front-run/spec/code/review loop — then tried porting the whole thing to Grok's harness. It works decently but subagent launches run way longer than regular sessions and the harness doesn't seem to fan out natively. A real datapoint on how non-portable loop engineering investment is between harnesses.

@bytetweets
https://x.com/bytetweets/status/2076072031771046178
Built Kamino451, a lightweight agent factory: tasks get matched to existing or new agents and different LLMs based on past performance of agent+model combos on similar tasks, task difficulty is scored with a relative Elo system, and an adaptation of Karpathy's autoresearch improves individual agents against an evaluation corpus. Collects agent traces for human error analysis. Agent selection as a learned, deterministic system instead of vibes.

@Yif_Yang
https://x.com/Yif_Yang/status/2075749979180900394
IdeaGene-Bench pushes autoresearch from paper retrieval to lineage-level understanding — the framing is that scientific ideas inherit, mutate and evolve, so an AI scientist with real research taste needs to track idea genealogy, not just fetch citations. A step toward autoresearch loops that understand where a hypothesis came from.

@RedBrickLabs_
https://x.com/RedBrickLabs_/status/2075971128376574102
Shipped an autoresearch skill for Codex: give it a goal, walk away, come back to a better codebase. It runs modify, verify, keep-or-revert in a loop overnight — Karpathy's recipe, generalized to any metric a command can measure. The interesting part is the porting: the loop pattern born in Claude Code is now harness-agnostic.

@JacobCounsell
https://x.com/JacobCounsell/status/2075735215008583952
His product is an agent loop that validates a product idea like a real product team would, then creates the MVP, forces Claude and Codex to write better code while saving tokens, generates the landing page and copy, and does the SEO — around 10 finished products making MRR so far. His rant: vibe coders do zero research, build slop into token limits, then blame distribution. The MVP was never the hard part; iterating to PMF is.

@krzyzanowskim
https://x.com/krzyzanowskim/status/2075974287387701642
Built an IDE with the agentic loop integrated as a first-class citizen rather than bolted on: loaded with crafted skills and tools, still a real code editor, with a local Linux VM included for running programs. The "agent-native IDE" category keeps getting new entrants from people unsatisfied with agent-as-sidebar.

@WhinyPuppy98
https://x.com/WhinyPuppy98/status/2075985955476177269
claude-code-from-scratch rebuilds Claude Code's core architecture in ~4,000 lines of TypeScript and Python: 14 standalone chapters covering the agent loop, tools, streaming, permissions, context compression, memory, skills, plan mode, sub-agents and MCP, each runnable with a mock model and no API key. Maps every component back to the real architecture and the why of each design decision. If you build with coding agents, understanding the loop beats any prompt trick.

@TheCoderBtw
https://x.com/TheCoderBtw/status/2075817359080906799
Small war story with a big lesson: his agent loop refused to start, convinced it was already running, because the alive-check substring-matched the whole command line — any process with the loop's name in its args tripped the guard. Fix: match argv[0] exactly. The unglamorous reality of running loops in production is exactly this class of dumb-but-fatal bug.

@killix
https://x.com/killix/status/2075974521933148542
An agent loop dropped a staging table yesterday; his observability platform scored the run 100% satisfaction. He found out when the morning build broke. The platform grades what the model said, not what the process did — it never showed the run as a job he could watch hold a connection and kill mid-flight. The sharpest short indictment yet of LLM-judge observability for destructive-capable loops.

@MannyKayy
https://x.com/MannyKayy/status/2075967196501512587
Friction report: Fable's safeguards blocked him from even updating his own autoresearch harness, which he calls effectively unusable for remotely interesting frontier work. Whatever you think of the safety tradeoff, autoresearch harness builders hitting model-level refusals is a new category of loop breakage to plan around.

@sun_hanchi
https://x.com/sun_hanchi/status/2076087159942189511
Token usage went up 10x after GPT-5.6 — not from babysitting, from the opposite. He throws the model into an autoresearch loop, literally "/goal don't stop keep working," hands it a list of ideas to try, and goes outside. The loop as default operating mode, with the human reduced to supplying the idea queue.

@pokorz
https://x.com/pokorz/status/2075908527650951247
Argues heuristic-problem competitions are a better proxy for ML autoresearch capability than any benchmark: if AI matches the best humans there, we are very close to recursive self-improvement and the automated researcher. His read is that this result class is way bigger than a high score on some questionable benchmark.

@cmd_alt_ecs
https://x.com/cmd_alt_ecs/status/2076064064607043625
Reads OpenAI's gpt-live as a latency tier, not a voice demo: a small fast full-duplex model holds the conversation while gpt-5.5 does search and hard reasoning out of band, folding answers back in. Applied teams have hand-rolled this split for a year; now it's productized. His actionable takeaway for loop builders: audit which of your turns are paying frontier latency for work a fast model could hold while the reasoner catches up async.