1. Running a Software Factory Efficiently at Uber Scale — Uber Engineering

  • Why read: How Uber scaled AI coding to thousands of engineers while actually cutting costs.
  • Summary: Uber moved from interactive AI chat to background agents that handle code reviews, bugs, and maintenance. This shift drove a 7x increase in active users and a 34% drop in cost per 1,000 requests. They saved money by routing tasks to smaller models, caching prompts with custom TTLs, and keeping MCP schemas out of context by using CLI tools instead. They also sped things up by packing multi-turn tool loops into single Python subprocesses. It shows that infrastructure matters as much as the models when scaling AI.
  • Read more

2. How Warp builds self-improving agents on Claude — Michael Segner

  • Why read: A framework for building agents that remember user feedback to improve their prompts over time.
  • Summary: Most agents forget feedback when a session ends. Warp fixes this by writing "skills" as plain text files. An observer agent looks at user feedback (like upvotes or comments) on the main agent's work, then opens pull requests to update those skill files. By focusing on principles and explaining the "why" behind instructions, agents make fewer repeat mistakes. This loop turns fleeting feedback into permanent knowledge.
  • Read more

3. Show Me the Receipts: The Case for Immutable Artifacts for Agent Work — Josh Rosen

  • Why read: Why we need agents to leave a permanent trail of evidence instead of just giving us the final answer.
  • Summary: If we want to trust agents with real work, we cannot just look at their final output. They need to create immutable artifacts along the way. By forcing agents to record hypotheses, evidence, and assessments, we get a verifiable graph of their thinking. If data changes, the agent writes a new version of its assessment instead of overwriting the old one. This paper trail builds trust and lets a new agent pick up a task without needing the original agent's entire context window.
  • Read more

4. WebMCP Clearly Explained — Akshay 🚀

  • Why read: A look at a new API standard that lets websites tell agents exactly what they can do, bypassing clunky visual scraping.
  • Summary: Agents usually navigate the web by guessing where to click based on screenshots. It is slow and breaks when buttons move. WebMCP lets websites expose a structured list of actions directly to the browser, complete with JSON schemas. Agents can then search or add to a cart within the user's active session without needing backend API keys. It is a faster way to make a site agent-ready without building custom infrastructure.
  • Read more

5. From Agent Memory to Portable Skills — Jocelyn Hoppa

  • Why read: How Neo4j turns messy interaction logs into reusable skills that save tokens and reduce errors.
  • Summary: Neo4j's Agent Memory Service prevents agents from forgetting how to do things between sessions. It records actions and outcomes into a graph, then distills them into a SKILL.md file. This file is not just text; it is a validated execution path. The system spots repeating actions and flags failing tools. After a quick human review, agents can load these proven routines at runtime, cutting down on token use and mistakes.
  • Read more

6. KV, Prefix, Prompt and Semantic Caching in LLMs, clearly explained — Avi Chawla

  • Why read: A technical guide to the four layers of LLM caching, how they work, and where developers mess them up.
  • Summary: Caching saves time and money, but you have to do it right. The KV cache stores data for one request, prefix caching shares it across requests, and prompt caching is what providers charge you for. Semantic caching uses vector embeddings to guess if a new question matches an old one; it saves output tokens but can serve up the wrong answer. To get high hit rates, you have to put variable data at the bottom of your prompt. Putting a timestamp or changing a tool schema at the top will break the cache for everything below it.
  • Read more

7. Agentic Kernels in Production — Brian Li

  • Why read: How AI agents are writing and testing optimized GPU kernels for production workloads.
  • Summary: Writing fast code for isolated benchmarks is easy; making it work in production is hard. This framework uses agents to profile an entire model and find ways to combine operations or skip redundant work. The agent tries different kernel designs at the same time, testing them for speed and accuracy. When applied to models like Qwen-Image and FLUX.2, the agents successfully merged operations and reduced overall latency by up to 42.3%. It proves agents can do real infrastructure optimization.
  • Read more

8. Open source models aren't actually cheaper than using Claude/Codex plans — Fletcher Richman

  • Why read: Why paying for a flat-rate Claude or OpenAI subscription is often cheaper than running open-source models yourself.
  • Summary: API pricing charts make models like DeepSeek V4 Pro look like a bargain, but they ignore the heavy subsidies in Claude and OpenAI subscriptions. Agent tasks constantly resend huge context windows. A $200/month Claude plan can easily provide $8,000 worth of API usage. When you factor that in, models like Claude Opus 5 and GPT 5.6 Sol cost less per task than open-source alternatives. The catch is that these plans usually cap at 150-200 seats. Until you hit that limit, it makes sense to max out subscriptions before setting up your own open-source infrastructure.
  • Read more

9. How speculative decoding makes LLMs go brrr — Leonie Monigatti

  • Why read: How speculative decoding speeds up text generation without dropping the quality of the output.
  • Summary: Normal text generation is slow because it predicts one token at a time, leaving GPU compute sitting idle. Speculative decoding fixes this by using a smaller, faster model to draft a batch of tokens. The main, larger model then checks that whole batch in one pass. It keeps the good tokens and corrects the bad ones. Because the main model has the final say, the output quality stays exactly the same. Newer methods like Medusa and EAGLE predict tokens straight from internal states, speeding things up by more than 3x.
  • Read more

10. Primer: Worktrees + Coding Agents — David Gomes

  • Why read: How Git worktrees let agents tackle multiple coding tasks at the same time without wrecking your local environment.
  • Summary: Git worktrees let you work on multiple branches at once without cloning the repo over and over. This is perfect for coding agents running tasks in parallel. Agents can use IDE-managed worktrees or create their own via the shell. Doing it themselves gives them flexibility to try different solutions or fix bugs in batches, but it can eat up disk space and break if setup scripts fail. As agents get better at multitasking, managing these worktrees properly is key to keeping local development smooth.
  • Read more

11. Teach the AI Your Judgment — Austin Johnsen from Artificial Diligence

  • Why read: How to train a model to make decisions like you do by feeding it your past choices.
  • Summary: High-end models are great at analysis, but they fail at company-specific decisions if you only give them generic strategy docs. Instead, feed the model your past decisions: CRM notes, Slack chats, and why you said yes or no. Ask the AI to figure out the implicit rules and triggers behind those choices. This creates a rulebook based on what you actually do, not what you say you do. Test this rulebook on old deals to find its blind spots. If you keep updating it with new decisions, the AI becomes a sharp proxy for your own judgment.
  • Read more

12. The AI Moat is Network, not Models — C.C. Gong

  • Why read: Why recent billion-dollar AI acquisitions show that owning the network matters more than having the best model.
  • Summary: Nvidia bought Hugging Face for $12.9B and Stripe bought OpenRouter for $7.5B. Neither acquired the best underlying model; they bought distribution. Hugging Face owns the developer community, giving Nvidia power to steer workloads to its chips. OpenRouter aggregates massive API traffic, giving Stripe data on AI usage and control over the payments. As models get cheaper and more interchangeable, the companies that control the access points and aggregate the users hold the real power.
  • Read more

13. AI/Data infra + dev tools M&A is having a moment — Janelle Teng Wade

  • Why read: Four reasons why massive tech companies are spending billions to buy up AI infrastructure and dev tools.
  • Summary: Tech giants are rushing to own the AI infrastructure stack. Nvidia bought into Poolside and Hugging Face to lock in future compute demand. SpaceX bought Cursor for $60B, showing that workflow tools can reach massive valuations if developers refuse to give them up. Stripe bought OpenRouter because tokens are becoming a core economic unit that needs billing and routing. AWS bought DuckLabs because AI analytics requires moving compute closer to where the data actually lives.
  • Read more

14. Clouded Judgement - 8.28.26 - Zero Data Retention — Clouded Judgement by Jamin Ball

  • Why read: Why enterprise companies are abandoning models that keep their data in favor of strict zero data retention policies.
  • Summary: When Anthropic launched Fable 5, they required a 30-day data retention period to check for misuse, ignoring existing zero-data-retention (ZDR) agreements. Microsoft and GitHub blocked it, and enterprises moved their traffic elsewhere. Security teams no longer trust policy promises; they want architectural guarantees that their data is not saved. Because of this, AI labs can no longer rely on customer data to train models; they have to use synthetic environments instead. CISOs now control AI buying, demanding proof that their data stays private.
  • Read more

15. How to Run the Perfect AI Implementation — Luke Pierce

  • Why read: A step-by-step guide to deploying AI at work without failing because of bad data and hidden workarounds.
  • Summary: Most AI rollouts fail because companies build them on top of messy data and hidden spreadsheets. To succeed, start by interviewing front-line workers to map out how tasks are actually done, not how management thinks they are done. Next, clean up your data architecture so there is only one source of truth. Lock down standard workflows before bringing in agents so they have reliable context. Finally, track adoption closely in the first 30 days to kill off old shadow processes before they ruin the new system.
  • Read more

Themes from yesterday

  • Distribution is the new AI moat: The latest wave of acquisitions shows that owning the network and the user workflow matters more than having the best model weights.
  • Cost and latency optimization: Making agents viable at scale means engineering the infrastructure—using prompt caching, smaller subagents, and speculative decoding to keep costs down and speeds up.
  • Verifiable agent architecture: If we want to trust agents, they need to leave a paper trail. They must generate clear, immutable records for every decision instead of just spitting out a final answer.
  • Zero Data Retention as a mandate: Enterprises are walking away from models that save their data. Strict privacy guarantees now control who buys what in enterprise AI.