AI++ // 1M lines and 7 reverts, agents without memory, and an app built live

Cockroach Labs published something uncomfortable this fortnight: their coding agent pipeline shipped over a million lines of code in 5 months with 7 reverts. Not 700. Just 7. Adam Storm and Rafi Shamim built what they call MOLT Sinai, a teaching hospital for bugs, where issues are patients, merging is discharge, and every plan gets a second opinion before anyone writes a line of code. The detail I keep coming back to is prompt rot: after 5 months, 23% of their skill files were flagged as redundant, with the same rule restated across 70 separate findings. Their prompts caught legacy code disease, and I suspect most teams chasing throughput won’t notice theirs until the token bill arrives.

The same theme ran through most of what was worth reading this fortnight: the model is fine, and the real work is in everything around it. Anthropic’s monorepo went from 2,500 merges a day to 30,000 in 6 months, which as Simon Willison wrote up was enough to need a custom replacement for Git. I’d taken for granted that infrastructure keeps up with velocity. Apparently it doesn’t, and 7 engineers spent 5 months finding that out.

In this edition of AI++ we look at what it takes to ship 1 million lines with 7 reverts, find out why your agents don’t need memory, and watch a wearables app get built live in public.

Erick Ramirez | Apache Cassandra committer & Developer Advocate at IBM/DataStax

🛠️ Building with AI, Agents & MCP

Harness engineering

The most actionable read of the fortnight is Vivek Trivedy’s write-up of how the team at LangChain improved Deep Agents on Terminal Bench 2.0 without touching the model. They kept GPT-5.2-Codex fixed and changed only the harness: a self-verification loop that stops the agent before it exits and makes it check its work against the original spec, loop-detection middleware that adds “consider reconsidering your approach” after too many edits to the same file, and a “reasoning sandwich” that uses higher reasoning effort for planning and final verification but drops to medium in between. The score went from 52.8% to 66.5%, which took them from outside the top 30 to the top 5. If you’re unhappy with your coding agent’s output, look at the harness before you go shopping for a new model.

LangChain also launched Open SWE, an open-source framework for internal coding agents built on Deep Agents and LangGraph, and published a model routing recipe that cut the median cost per coding task by 64% with no measurable drop in quality. The trick is to push sub-tasks to smaller models inside the harness and escalate to the large model only when it’s needed. LegalOn did the same with OpenAI’s model family and cut Codex costs by 65% without slowing development down.

Agent memory

Kevin Liao published a sharp post arguing that the whole RAG-based memory plugin ecosystem is solving the wrong problem. Every memory plugin works the same way: extract snippets from session history, stuff them in a vector database, then retrieve the top 5 on each prompt. His objections are fundamental. Similarity search doesn’t know what’s current, an agent can’t search for what it doesn’t know is missing, and nobody can audit the store. His alternative, Operator Memory, is structured on-disk documentation that the agent reads before it starts and updates when it’s done, and it’s open source.

Read it alongside the Cockroach Labs piece, because MOLT Sinai reached the same conclusion independently: their agents keep append-only precedent logs, per-issue records and role skill files that act as living documentation. The teams getting good results from coding agents aren’t relying on memory. They’re writing things down.

Multi-agent teams

Vals AI ran a direct cost/quality comparison of single agents and multi-agent teams on Vibe Code Bench, using GPT-6 Sol and Claude Opus 5.5. The teams cost 1.8 to 5.1 times as much, and in most conditions there was no statistically significant difference in quality. The exception was Sol at medium reasoning effort, where the team helped. Their conclusion is that higher reasoning effort is usually a better investment than more agents. I don’t think this makes multi-agent teams useless, but it’s a handy correction to the idea that more agents means better results.

🧠 New models

Claude Haiku 5.5 is Anthropic’s cheapest and fastest model yet, and Latent Space’s benchmarks put it ahead of GPT-6 Luna at the same price point. If you’ve got work routed to a larger model, it’s worth a re-test.
Gemini 4 Argon is now generally available, with a 1M output context window and a separate robotics-tuned variant. CursorBench independently confirmed the benchmarks Google published two weeks ago, so the numbers hold up outside Google’s own tests.
Mistral Large 4 is a 1T-parameter multimodal model from Europe. If you’re building for EU customers with data residency requirements, it’s the most capable GDPR-friendly option I’ve seen.
GPT-6 and Intelligent UI rolled out globally in ChatGPT. Intelligent UI generates interactive, visual responses right in the chat, so if you’re building on the ChatGPT platform, a response can now look very different.
GLM-5 and MiniMax M2.7 now match closed frontier models on core agent tasks (file operations, tool use and instruction following) at lower cost and latency, according to LangChain’s evals. That isn’t the model makers talking, it’s the team running them in Deep Agents. Worth testing if you’re watching costs.

🗞️ Other news

OpenAI published 722 mathematics papers from an internal frontier model, with Lean formalisations on GitHub, and claims 90 of the top 500 open problems addressed. That’s a big claim, and I’m keen to see how much of it survives review by mathematicians.
Deno is joining Cloudflare. Deno runtime development ends after 1 year of security updates, Deno Deploy shuts down in 6 months, and JSR continues. If you have anything running on Deno Deploy, start planning now.
Anthropic published a detailed report on unintended model actions observed during evaluations, such as exploiting software flaws, submitting forms incorrectly and bypassing data restrictions. The real-world impact was minimal, but the transparency is useful if you’re designing production safeguards.
turbopuffer is dropping the vector-primary index in v3, and ANN becomes a secondary index. The reasons are refreshingly honest: write amplification, storage amplification and limited vectorisation all trace back to the original design choice. It’s a good technical read on where vector-first architectures hit a wall.
Ars Technica reports that AI coding agents generate more code but not more software. Keep it in your back pocket for the next time someone confuses lines of code with shipped product. Yes, I see the irony after that cold open.
Microsoft-Decision-1 is now in Microsoft Foundry and OpenRouter, a single-pass model for routing, classification and workflow control. The same week, Cloudflare released Clef-omni, a decision model that takes audio, video, images and text for $0.038 per million input tokens on the flash tier. Decision models are becoming commodity infrastructure.

🧑‍💻 Code & Libraries

Deep Agents is an open-source framework for building long-running agents that handle complex, multi-step tasks
Open SWE is an open-source framework for internal coding agents built on Deep Agents and LangGraph
Operator Memory is a context engine that gives agents structured on-disk documentation to read and maintain across sessions, with no vector database required
Talorys is a self-hosted personal AI agent that deploys to Cloudflare’s free tier in a single command, with chat, memory, tasks, and scheduled reminders
Janas is a runtime for serving LLMs larger than available RAM by streaming expert layers from SSD
Magnitude is a self-optimising inference engine for agents that routes sub-tasks to the most cost-effective model automatically

🔦 Langflow Spotlight

Langflow’s Smart Router does what it says on the tin. It’s an LLM-powered component that sorts incoming messages into categories you describe in plain language, then sends each one to the right output. Connect a Language Model, give each route a name and a description, and add an “else” fallback for anything that doesn’t fit. The Langflow team highlighted a neat use this week: route by complexity, so simple queries go to a faster, cheaper model and the hard ones go to the capable one, all in the same flow. If you’re still routing with string matching, give it a go.

🗓️ Events

Aaron Ploetz from the IBM Developer Advocacy team published a thorough technical walkthrough of vector search in Apache Cassandra on the IBM Community. It covers the JVector library, CQL’s ANN OF syntax and how to choose between cosine, dot product and Euclidean similarity, with complete Python and C# examples using the IBM Granite embedding model.

I also published week 4 of the cMovie series, which builds a FastAPI endpoint for semantic search on Cassandra 5.0. Two things to know before you build your own: ANN OF needs a LIMIT, capped at 1,000 by default, and vector queries only run at consistency level ONE or LOCAL_ONE, so Cassandra downgrades anything stronger and sends you a warning.

And if you’d like to watch an app get built, David Jones-Gilardi and Tejas Kumar are building Walfly, a wearables app, live on YouTube. The latest episode brings in Jev, TypeSafe’s decision model served through OpenRouter’s Decisions API, to sort recorded “moments” into categories quickly and cheaply. It’s the same kind of decision model as the ones in Other news, so it’s a nice chance to see one doing a real job in an app.

Enjoy this newsletter? Forward it to a friend.