1. Compilers 2.0: AI as stochastic optimizer — X (formerly Twitter)

  • Why read: How OpenAI uses AI as a "stochastic optimizer" to write MLA kernels that beat traditional compiler heuristics.
  • Summary: AI is starting to act as an optimizing compiler. Instead of using rigid heuristics, models take multiple shots at optimizing math operations down to low-level primitives. Since these operations have strict contracts, you can verify the output works without having a human read the code. This pushes the "assembly code" boundary up the stack: teams can feed high-level math to the model, wait two days, and get back kernels that run faster than human-written ones.
  • Read more

2. Building the missing layer between AI spend and ROI — X (formerly Twitter)

  • Why read: How to build a data layer that maps raw token usage to actual business outcomes.
  • Summary: Tracking token costs doesn't tell you what your agents are getting done. Ramp built a pipeline that turns agent traces into "work items," linking scattered sessions into full runs with specific goals. They use LLMs to classify these items without forcing them into a rigid taxonomy. By compressing the traces to save money, they scaled this across hundreds of thousands of sessions. Now, their finance and product teams can tie token spend directly to merged PRs and closed tickets.
  • Read more

3. Agent Memory Roundup 2026: The Race to Build Universal Memory for AI — X (formerly Twitter)

  • Why read: Why agent memory is moving out of individual models and into shared data infrastructure.
  • Summary: Multi-agent setups require agents to read and write to the same knowledge base. In response, providers are building external memory systems that treat memory as a durable resource with clear ownership. Approaches include temporal knowledge graphs that track fact changes over time, shared memory blocks resembling OS state, and managed extraction infrastructure. Structured memory is becoming a standalone layer in the AI stack. Developers should build agents as clients of this shared memory, rather than treating memory as an LLM feature.
  • Read more

4. WebMCP: building for agents on the open web — X (formerly Twitter)

  • Why read: A look at an experimental web standard that lets websites expose tools directly to AI agents.
  • Summary: WebMCP lets humans and AI agents interact with the same web app in the same browser session. Instead of scraping the DOM, websites expose a standard tool interface directly to the agent when it loads the page. This skips the need for plugins and allows immediate collaboration, like cooperative document editing or gaming where the human and agent manipulate the same state in real time.
  • Read more

5. The Surprisingly Complex Art of How Software Factories Break Down Work — X (formerly Twitter)

  • Why read: How to translate high-level goals into specific tasks for autonomous coding agents.
  • Summary: The hard part of building a software factory isn't writing the code; it's breaking down the work. While LLMs can delegate via prompts, scalable systems need a durable task graph coordinated by traditional schedulers. The best setups organize work around policies, validation checks, and specific outcomes rather than static checklists. Since software development involves discovery, these task graphs have to be dynamic so the system can split or add tasks as it learns. Orchestrators and agents must share the same work schema to avoid getting out of sync.
  • Read more

6. PRs NOT Welcome: How Top AI Open Source Projects Are Managing Thousands of Contributors — Substack

  • Why read: Why major open-source projects are rejecting external PRs and using their own agents to write code instead.
  • Summary: Open-source projects like Vercel's AI SDK, Astro, and tldraw are rejecting community pull requests because they are flooded with low-quality AI spam. Instead, they use internal agent teams to triage bugs, reproduce issues, and write fixes. Maintainers find it faster to let their optimized internal agents write code based on issue threads than to review external PRs. This shifts the community's role from writing code to reporting bugs, discussing architecture, and specifying features. It treats issues as leads and rewrites the open-source model.
  • Read more

7. Running Salesforce Headless: Our 'Claudeforce' Journey — SaaStr

  • Why read: What happens when a company abandons the Salesforce UI and uses agents to manage CRM data.
  • Summary: The SaaStr team hasn't logged into the Salesforce UI in six months. They use over 20 production AI agents to manage the data instead. They found that agents handled the busywork without messing up the data. This "headless" approach suggests that API access and data gravity matter more than the user interface. SaaS companies should expect their primary users to be agents, not humans.
  • Read more

8. Your AGENTS.md is holding you back — X (formerly Twitter)

  • Why read: Why long context files degrade agent performance, and how to fix them.
  • Summary: Overly detailed context files like AGENTS.md can hurt performance by limiting a model's reasoning. Teams need to delete redundant rules and rely on the model's baseline intelligence. Delete any instruction that isn't actively preventing a known failure. PostHog treats context like code, using CI pipelines to test agent behavior against sample apps. By having agents log the issues they hit, you can build a feedback loop to keep context files lean.
  • Read more

9. SaaS Companies Need a New Data Model for Agents — X (formerly Twitter)

  • Why read: Why SaaS platforms need to track the context of work to stay relevant for agents.
  • Summary: SaaS companies either build closed agent ecosystems that frustrate users, or expose APIs and become dumb pipes. The fix is building a "work plane": a data schema that tracks goals, evidence, plans, and decisions alongside core records. By storing this working context, the SaaS product remains valuable while letting customers bring their own agents. External agents no longer have to rebuild context from scratch every time they run. Using the Model Context Protocol (MCP) to implement this keeps the data sticky while staying interoperable.
  • Read more

10. Compute Is Already Trading — X (formerly Twitter)

  • Why read: How GPU compute is turning into a financial asset class with derivatives and term structures.
  • Summary: Hardware is financed with multi-year commitments, but buyers want short-term, on-demand compute. This mismatch creates a risk premium. Traders are now buying multi-year compute blocks and reselling them at a spread. Compute is a weird asset: you can't store it, and its price drops sharply when new hardware releases. Firms like Liquid Compute are building reference indices for cash-settled contracts and trading between chip generations. Operators and lenders need to realize they hold a position on this curve and can hedge their hardware exposure.
  • Read more

11. x402 | Saving The Internet From Its Original Sin — Substack

  • Why read: A look at x402, a new internet standard using stablecoins for agent micro-transactions.
  • Summary: The internet never had native payments, forcing us to use credit cards and subscriptions that are too slow for AI agents. x402 is a standard built on the unused HTTP 402 "Payment Required" code, letting software request and pay for resources programmatically. Using low-cost blockchains, it handles sub-cent transactions without human checkouts. Since agents consume tokens much faster than humans, these micro-payments enable API business models based on per-request billing. This gives software a way to transact autonomously at scale.
  • Read more

12. Nobody is talking seriously about AI demand — X (formerly Twitter)

  • Why read: A framework dividing AI tasks into "bounded" and "unbounded" to explain the economics of frontier models.
  • Summary: The market assumes infinite AI demand without asking which tasks actually justify the cost of frontier models. Demand splits in two. "Bounded" tasks like accounting are capped by cost savings and will go to cheap, non-frontier models. "Unbounded" tasks like AI R&D and quant trading create a loop where spending on advanced tokens drives revenue. This loop justifies massive spending on frontier models to stay first. But because this demand is tied to high-stakes, correlated tasks, the whole system is vulnerable to economic shocks.
  • Read more

13. “I’m Churning” | 10 Biggest Threats to SaaS — Substack

  • Why read: A CFO explains why AI is changing B2B software purchasing and causing legacy SaaS churn.
  • Summary: CFOs are cutting traditional SaaS budgets to fund LLMs. Buyers now compare the high cost of workflow software against the low cost of foundation models, which ruins the ROI for legacy tools. Switching costs are lower because AI makes data migration easier. On top of that, internal teams can quickly build custom alternatives, giving buyers leverage at renewal time. SaaS vendors need to prove their worth, integrate with protocols like MCP, and rethink their pricing.
  • Read more

14. The Price of Entry to the Frontier — X (formerly Twitter)

  • Why read: Why the frontier AI market is fracturing into closed ecosystems and exclusive partnerships.
  • Summary: The idea of a pluggable, model-agnostic AI ecosystem is dying. Frontier labs are gating their best models and signing exclusive deals. Salesforce hardcoded Anthropic; OpenAI cut off API access for competitors. Access, not price, is the new bottleneck. Even open-weights models are adding revenue triggers that require security reviews for large cloud hosts. Governments are treating frontier models as sovereign infrastructure and controlling who runs them. In response, Nvidia is funding open ecosystems to prevent a few labs from locking down the market.
  • Read more

15. The Complete Guide to pstack Pt. 1 — X (formerly Twitter)

  • Why read: How to build "verification skills" so coding agents can test their own work.
  • Summary: Agent productivity means nothing if the code is bad. Teams need "verification skills": custom CLIs that let agents natively debug and test the app. Giving agents concrete tools instead of long text prompts saves tokens and makes them more reliable. A "Feature Map" helps agents navigate large codebases by serving as external memory. Pairing these verification loops with cloud agents lets teams parallelize hundreds of tasks without ruining their codebase.
  • Read more

Themes from yesterday

  • Factories over PRs: Open source projects and internal teams are dumping ad-hoc prompts and external PRs. They are building structured software factories and automated test loops instead.
  • Agent infrastructure: The internet is being rewired for agents. New standards like HTTP 402 micro-payments, shared memory planes, and WebMCP treat agents as primary users.
  • Headless SaaS: The SaaS UI is losing value. Buyers are using agents to bypass interfaces, cut costs, and manage data directly.
  • Trading compute: GPU capacity is now a financial asset. Traders are buying multi-year blocks and reselling them to buyers who want short-term capacity.
  • Context minimalism: Long prompt files hurt performance. Teams are deleting rules and relying on the model's baseline intelligence combined with strict verification tools.