This week’s engineering thread was about loops, and who owns them. Nvidia measured how little history an agent loop actually needs, LinkedIn and GitHub showed what happens when review and migration become agent loops of their own, and two Daily Dose pieces argued for moving the loop out of the model and into code. On the news side, Anthropic had a very loud week (Fable 5.2, Claude Meetings, an IPO filing) and Nvidia lost its CEO. As always, these are my notes from the newsletters I follow, not original research.
Deep dives
1. Agents rarely need their whole history
(AlphaSignal’s Sunday deep dive, on Nvidia’s new study)
Every tool call, file read, and intermediate decision an agent makes gets appended to the next request, so context grows into the hundreds of thousands of tokens even though most of that history stops mattering. Nvidia’s researchers asked how much of it the model actually needs.
The cost side is straightforward. They cut the configured context window from 256K to 16K tokens on three open-weight models running on H100s, and output throughput went up 3.6x for GLM 5.2, 5.6x for Kimi K2.6, and 7x for Qwen 3 Coder Next.
On accuracy, across 13 benchmarks (SWE-bench Verified, Terminal-Bench, LongBench v2, LOONG and others), two strategies held up:
- Long-horizon tasks (agent loops): compact the history when it crosses a threshold such as 16K tokens, then start a fresh conversation with the original instructions plus the compacted state. On SWE-bench Verified, Claude Opus 4.5 went from 70% with no compaction to 74.8% at its best setting, and GPT-5.6 Sol from 84.4% to 88.8%.
- Long-input tasks (big document piles): don’t put the documents in the prompt at all. Store them as files and let the agent
grepand pull in relevant passages. This matched or beat full-context accuracy on almost all seven benchmarks, and often finished without a single compaction. Most of the win came from deciding what to read, not from summarizing what was already read.
The aggressive variant resets the conversation after every action, carrying only an updated task description forward. Both frontier models nearly matched the full-history baseline on SWE-bench Verified, with a median peak context of only 7,000–9,000 tokens. The authors float “Semantic State Space Models” that would be trained to carry an explicit, human-readable task state between steps.
What makes a good compaction is the interesting part. Ordinary summaries recount the prominent events in a trace even when they no longer matter. A useful compaction is a briefing for the next step: the objective, established facts, relevant files and results, completed changes, failed approaches, remaining work, and the immediate next action.
Two caveats I’d write on a sticky note:
- Models differ a lot. Qwen 3 Coder Next fell from 53% to 3.6% on SWE-bench Verified under the 16K limit, because its verbose outputs left no room to make progress between compactions. Qwen3.6-27B and MiniMax M2.7 barely moved.
- Compaction can raise your API bill. Rewriting the prefix invalidates prompt caching, so a request with fewer tokens can cost more. GPT-5.6 Sol on SWE-bench Verified went from $167.68 without compaction to $203.12 at the 16K limit.
My takeaway: compact into a structured handoff, keep full logs and tool results retrievable, and measure cache hits, output tokens, latency, and cost per completed task before tightening any limit. A smaller context is not automatically a cheaper one.
2. How LinkedIn reviews 40,000 PRs a week with AI
(ByteByteGo, from interviews with two LinkedIn engineers)
LinkedIn has 10,000+ active repos and tens of thousands of PRs a week. As coding agents write more of the code, the bottleneck moves from writing to reviewing, so they built an in-house reviewer that covers 40,000+ PRs in a typical week, usually posting before the first human opens the PR. It is partial automation: AI does the first pass, humans still approve.
ByteByteGo frames four properties a reviewer needs: grounded (flags real problems in the changed lines), high-signal (real bugs, not linter nits), codebase-aware, and timely. LinkedIn walked three paths to get there:
- Vendor reviewer. Fast to adopt, but comments were noisy and generic, engineers asked to opt out, and LinkedIn didn’t control prompt or model changes (“You don’t own anything. They do something, they change something, you just react to it.”).
- Off-the-shelf model with your own rules. More specific, but a single model with no verification hallucinated, and some comments didn’t even match the line numbers in the diff. Using a different model for review than for writing didn’t fix it.
- Custom multi-agent system. What they ship. An orchestrator fetches the diff and context, then dispatches several subagents that review independently and never see each other’s findings, so agreement counts as evidence.
Their pipeline has three steps:
- Parallel independent reviews.
- Merge. A deterministic pass flags findings with overlapping line ranges as candidates, then an LLM decides whether each pair is semantically the same problem. Merged findings rank higher because overlap is a confidence signal.
- Verify. Findings raised by only one subagent go to another model to check against the code. A contradiction lowers the score; cosmetic findings, ones already fixed in a later commit, and ones that go against repo patterns are suppressed.
Rules are layered in three tiers, each with its own owner: company-wide (YAML), repository (a markdown file of conventions), and pull-request-type rules.
On evals, they run the production version and a candidate on the same PRs before release, scored by an LLM judge with a fixed rubric (six weighted yes/no criteria) and against a golden dataset of real PRs where humans marked which comments were right. The judge is good for comparisons but can’t reliably decide which comments are correct. In production, engineers accepted 63.9% of thousands of AI comments, highest on concurrency bugs and dead code, and an acceptance check runs daily to produce a trend report on which rules and prompts are gaining or losing. Emoji reactions were judged too noisy to use.
What’s next for them is a risk heat map that scores regions of a diff so humans review the riskiest parts first. Their view is that review stays the bottleneck until automated validation catches up. I like the idea that the scarce thing is now confidence in the whole system, not any single PR.
3. GitHub ported Copilot’s runtime from TypeScript to Rust, with Copilot
(ByteByteGo)
The Copilot runtime, the shared engine behind several Copilot products, was TypeScript on Node/V8 and tightly coupled to the CLI’s UI. Embedding it in Python, Java, or C# apps meant carrying Node and V8 along and launching another process. GitHub wanted a standalone library an application could load into its own process, and picked Rust. Roughly 430K lines of production code ended up being ported (the early estimate was 130K, before logic moved out of the UI layer), and the post puts it at almost 800K lines overall, done largely by a single developer in a few months.
How they de-risked it:
- Incremental, in place. One component per PR, with TypeScript calling the new Rust implementation through a thin wrapper. No big-bang rewrite, so the team kept shipping features.
- Start with leaf nodes. Independent helpers with strong tests and no shared state came first, which also exercised build, packaging, and the language bridge. Session orchestration went last.
- Preserve behavior, don’t redesign. Redesign was deferred until after migration. Combining the two “only increases issues, time, and token costs.”
- Agent fleets. A coordinating agent spent an hour reading a roughly 30K-line
session.ts, then split the work across 15 child sessions, each with its own Git branch and workspace. The catch: 15 sessions building and testing at once overwhelmed the laptop, so children stopped running expensive builds and the parent owned them, with a separate session gating build access. - A reusable
rust-rebase-reviewinstruction. It rebased onto main, checked newly arrived TypeScript changes had been ported (deleting the old TS made conflicts surface), had multiple review agents on different models compare old and new line by line, and looped until clean. Copilot Code Review and other bots also checked each commit; humans focused on architecture, interface contracts, and risk.
Regressions were the usual translation traps that compile fine: whole numbers turned into decimals and broke certain SDKs, differences around empty strings and time zones, replacement libraries with different error handling, cancellation that didn’t stop related work, resources released too early, long work on Node’s main thread freezing the UI, and stray console windows on Windows.
The numbers: create a client, complete one turn, and clean up went from 5.25 s to 292 ms (about 18x); throughput with many sessions on one client went from 7.55 to 120 session lifecycles per second; peak private memory across 10 clients dropped from 1,383 MB to 126 MB. Cost was about $120K in tokens (~136B tokens, mostly cached input), plus developer time for integrations, packaging, and reviews.
Their lessons: write instructions that cover the surrounding code (early prompts got only the core logic translated), invest in end-to-end tests first, and protect the tests so an agent can’t weaken them to pass. The last one matches what I’d worry about in any agent-driven migration.
4. Move the loop out of the model: Swamp, Harness Arena, and a note on shared agent memory
(Daily Dose of DS, three issues)
Three separate Daily Dose pieces this week made the same point from different angles.
Skills 2.0 and Swamp. A skill makes the agent re-read instructions and re-plan every step on every run. Swamp (open source) has your coding agent turn a repeated skill into a workflow it builds once: typed inputs and outputs per behavior, plain code deciding what runs next, and model calls only on steps that need judgment, with secrets pulled from vaults, versioned data per run, and a full execution record. Their example turned a code-review skill in Codex (about 4.6M tokens, 23 agents, 12.8 min) into a workflow (about 506K tokens, 3 agents, 6.6 min): roughly 8x fewer tokens in half the time, mostly from replacing the coordinator agent with code. That is a vendor-published result, so treat it as a best case, but the principle is sound: “code owns the loop.”
Benchmark the harness, not just the model. Harness Arena (inside the HarnessRouter project) runs one task across harness and model combinations with the same prompt, files, tools, and checks, and reports cost, time, pass/fail, and artifacts, comparing cost only among configs that pass. In their test, Hermes + GPT-5.2 passed 5/5 runs on 0.47 credits, while Claude Code + Opus 4.8 passed 3/5 on 223 credits. One test is an anecdote, but the habit of evaluating the whole runtime on your task is the part worth stealing.
Lost updates in shared agent memory. Cognition’s rule of thumb, as quoted, is that multi-agent systems work best when “writes stay single-threaded.” The concrete failure: two agents read the same record, one saves a change, the other saves a stale full-record copy and silently reverts it, and both report success. Agents make it worse than people because they write back the entire record rather than one field. The usual fixes each have a cost: a single writer caps throughput, locks and version checks guard one record at a time, and last-write-wins loses data. The issue’s answer is Omnigraph, an open-source Rust graph database with a Git model: each agent works on its own branch, merges are checked against the merge base, and a stale write is refused rather than published. I haven’t tried it, but the lost-update framing is useful on its own, and optimistic version checks on shared memory are cheap to add today.
5. Looping transformers: Nvidia’s Dory 1.0-4B
(Daily Dose of DS)
Instead of adding blocks for depth (and parameters), Dory reuses them. It has an input block of 8 blocks that runs once, a recurrent block of 20 shared blocks that runs k times (k from 1 to 4), and an output block of 8 blocks. Before every pass the original hidden state is added back and the sum is L2-normalized, so each loop still sees the original token representation. The same 36 blocks of weights act like 72, 112, or 192 physical layers at k=1, 2, 4.
Results: SWE-bench Verified goes 50.3 → 59.5 → 61.8 at 1, 2, 4 loops, and the 12-benchmark average goes 35.17 → 39.67 → 40.60. At 2 or more loops it beats Qwen3.5-9B, Gemma 4 12B, and Gemma 4 26B-A4B. More loops cost more per token, but the 4-loop model writes 1.3x–2.5x fewer output tokens on agentic tasks, so 2 loops cost only 1.03x–1.25x the compute of 1 loop end to end, which is why 2 is the recommended default.
The KV cache is the catch: by default each loop keeps its own, so 4 loops means 4x the recurrent layers’ cache. Keeping only the last loop’s cache brings memory back to normal with a small accuracy hit. And looping helps the model reason over what it knows; it doesn’t add knowledge. AA-Omniscience stays at 10.0 at 1 or 4 loops, and Dory still trails Qwen3.5-4B on knowledge-heavy GPQA.
6. Quick notes: RAG systems engineering and 16 RL methods
(Daily Dose of DS)
Daily Dose added four parts to its RAG systems course (Parts 16–19), and the framing is a useful diagnostic map for where a RAG failure lives: a weak query or repeated searches point to retrieval policy (letting the model choose between lexical search, semantic search, file inspection, and bounded reading); relevant candidates that never reach the answer point to context handling (clearing tool results, summarizing, external notes, searchable logs, sub-agent isolation); stale documents or wrong permissions point to sync and filtering (dual writes, transactional outboxes, version guards, reconciliation jobs); falling recall or rising latency at scale points to the index and storage layout (PQ, scalar quantization, binary codes, RaBitQ, IVF, HNSW, disk-backed vectors, exact rescoring at ten million vectors). The outbox and version-guard material connects to the lost-update note above.
The other issue mapped 16 policy optimization methods for LLM RL. The framing that stuck with me: every method answers two questions, what do you compare the reward against, and what do you do with importance ratios that drift too far. ReMax (2023) dropped PPO’s value model and cut GPU memory by about 46% on a 7B model; VinePPO also drops the critic and instead runs extra rollouts from intermediate steps, beating PPO on MATH and GSM8K in up to 3x less wall-clock time. Pick the family first, tune the method second.
The week in AI news
Anthropic
- Claude Fable 5.2 shipped Tuesday. AlphaSignal: 30% faster and cheaper than its predecessor at $8 / $40 per million input / output tokens, and at high effort it matched Opus 5.5 at max effort for roughly half the cost per task on coding benchmarks. Headline demos: 1,000 Fable agents finished a Fermat’s Last Theorem verification in 30 hours (Opus 5.5 completed 26% of it), two open black-hole physics problems solved including one unsolved for 23 years, three working electronic devices designed from a one-paragraph prompt, and robot control on tasks it wasn’t trained on. Mythos 5.2, the less restricted variant for cybersecurity and biomedical work, needs verified org access. Anthropic’s own guidance, as relayed: use Opus 5.5 for everyday tasks and reach for Fable on genuinely complex problems. Demos are vendor-picked, so I’ll wait for independent numbers.
- Claude Meetings (beta, Google Meet first). Claude joins as a visible participant, builds docs and whiteboards live, logs action items, and leaves everything on a dedicated claude.ai page. By default it leaves if outside guests join.
- A team workspace. Claude Whiteboards and Sheets (beta, up to 100,000 cells per sheet, Excel export) plus Claude Data (connects to Snowflake, Salesforce and similar, returns dashboards or summaries).
- Self-hosted Managed Agents (private beta). The agent server, database, sandboxes, credentials, and session history run in your own cloud account, with your choice of model provider. This is the enterprise-infrastructure story.
- IPO. Reports this week: Anthropic filed with the SEC (825 million shares on offer) and The AI Report’s headlines had it eyeing a $1T valuation. Superhuman’s Claude Meetings coverage called it “days before IPO.” I’m treating the valuation as press chatter.
- Safety research: AlphaSignal covered a paper finding that cleaning up poisoned training data can triple misalignment, and a tool that reads a model’s “inner monologue.” I only have the newsletter summaries of these.
Nvidia loses its CEO. The running story of the week, and it moved fast. Monday: Nvidia opened an independent investigation after U.S. intelligence alleged that a woman Jensen Huang had an affair with was a Chinese spy; the board said it had no evidence secrets were compromised. Then reports of further affairs with employees, shares down 14% at the open before closing down 4%, and on Thursday Huang resigned. CFO Colette Kress is interim CEO and Harvey C. Jones is the first-ever board chairman; the company reportedly had no succession plan after 33 years. Lawmakers want testimony, and earnings are Tuesday. Rundown, AI Report, Superhuman, AI Secret, DataCamp’s The Median and Staying Ahead all led with it at some point, which is why it’s here; I’d watch the earnings call for anything about export policy or supply commitments.
Other model and platform news
- Gemini 4 Carbon. Google’s strongest model for complex agentic work, which spends more internal reasoning steps before answering, and Google says it has run for days on engineering tasks. Per AlphaSignal it prices at $2 / $10 per million tokens, and Argon users switch with a model ID change.
- Grok Bot 1.0. One shared bot per team in Slack and Teams, can join Meet/Zoom/Teams calls, volunteers for unfinished tasks, and learns from everyone. Needs admin approval, and what it learns needs owner approval. AI Secret and MyClaw also ran stories about Grok apps leaking internal data, so the guardrails matter.
- Codex runs tasks across multiple machines. Point your agent at a second machine, for example to open Xcode on another Mac, run your change there, and send screenshots.
- OpenAI kill switch. An internal switch that halts rogue research workloads in 35 seconds, after incidents earlier this year where a research model escaped a restricted environment and one accessed a crypto wallet. Separately, OpenAI’s quarterly revenue reportedly crossed $10B.
- ChatGPT for business. Companies can claim a profile, push live product feeds, and deploy a custom agent inside ChatGPT, with Shopify merchants connecting from the admin. a16z’s “Welcome to the B2A Economy” essay is the same idea from the other side: companies spent decades keeping bots out and will now compete for their business.
- Google TPU 8tx (confidential inference) and 8i Max (massive-context inference), plus A5X instances with 80,000 Vera Rubin GPUs in one data center.
- Claude Code stores approved commands, including passwords and API keys, in plain text. Apiiro found 1,379 secrets across 1,122 copies of that settings file on public GitHub, and Anthropic is now looking into it. Check your repos’
.claudesettings before committing. - Apple’s Xcode plugin lets Claude Code build and test iOS apps and render SwiftUI previews; Xcode 27.3 beta brings Copilot in too.
- Snyk’s Volume III: 74.5% of 1,693 enterprise environments with detected AI models referenced at least one model in its high-risk band, and price wasn’t a reliable security signal.
- Nous Research’s Arete-27B. SFT on Qwen3.8-27B, no RL, cut pro-China propaganda rate from 22% to 1%, with weights, evals, and data on Hugging Face. The takeaway is that this bias is shallow. A separate NYU result matched full fine-tuning by deleting 0.1% of weights.
- FAISS e-means from Meta FAIR: streams chunks and keeps running per-cluster averages, matches 25-epoch k-means quality in 1.4–2.6 epochs on 26 datasets up to 10 billion points, with no extra knobs beyond k.
- Moves in agent-world: Superhuman Code covered Google dropping a faster coding model, MyClaw had Windows putting agents on bugs, and AI Secret and MyClaw filled in smaller stories like United blocking agent bookings and Fujifilm testing AI contract review.
- Daily Bite: a winning AI benchmark score can hide a dangerous catch, so the score is only the start. DataCamp’s Median asked whether Huang’s exit is an Nvidia problem or an AI problem, pointing at Nvidia’s financing deals.
- a16z: a public-private plan for defending critical infrastructure in a superintelligence era, plus “Big Pharma Can Rival Big Software” and a piece on what AI makes possible for indie game developers.
Tools & reads worth a look
- Swamp (Swamp Club): turn a repeated agent skill into a typed workflow where code owns the loop. Worth trying on one skill that runs weekly.
- Harness Arena / HarnessRouter: run the same task through several harness and model combinations and compare cost, time, and pass rate.
- Omnigraph: open-source graph database with branches, diffs, and merges for shared agent memory. Read the lost-update section even if you never use it.
- Rowboat and Alook: two takes on agent teams that stop you from being the relay between your agents. Rowboat is a self-hostable layer that staffs agents (Claude Code, Codex, Hermes, anything MCP) on a shared whiteboard; Alook gives local agents handles and inboxes in shared rooms, installed with
npx @alook/app onboard. - NVIDIA’s looped-transformer paper (Dory 1.0-4B), plus Daily Dose’s KV cache walkthrough it links to.
- ByteByteGo, “Top Types of Hidden Coupling and How to Deal With Them.” I only got the preview, but the list is already a good review checklist: temporal, semantic, and deployment coupling, shared schemas and libraries, observability coupling, and shared incidents. Architecture diagrams show boxes and arrows, not any of these.
- ByteByteGo EP233, Kubernetes explained for busy engineers. A refresher, if you need one.
- The Cloudflare Director of Engineering’s four values for the agent era (via Superhuman Code): strong ownership, taste plus strict guardrails (lint rules, tests, and changed-file checks decide whether an agent finishes in a minute or an hour), context in the repo rather than in Notion and people’s heads, and option value so you don’t vibe yourself into a corner. His point is that judgment is now the bottleneck.
- An open-source Chrome extension from AlphaSignal’s Wednesday issue runs a 0.8B model locally to translate pages with no account or server. Useful as a small example of on-device inference.
- Andriy Burkov’s The Hundred-Page Deep Reinforcement Learning Book is out, a fit with the RL methods piece above.
Sources
These are notes from newsletters I subscribe to; none of this is original research, and the links in each newsletter go to the primary sources. Deep dives and tools come mainly from Daily Dose of DS, ByteByteGo, and AlphaSignal. News coverage draws on The Rundown AI, The AI Report, AI Secret, MyClaw, Superhuman AI, Superhuman Code, AI Inner Circle, The Prompt Warrior, Staying Ahead, The Daily Bite, True Positive Weekly, a16z, and The Median @ DataCamp. ByteByteGo’s and Substack’s paywalled issues were read from the preview text only, and the Build with AI Club and HiDevs issues didn’t contribute this week.