1. How to Design an Agent Harness: six decisions that turn a model into a worker you can leave alone — X (formerly Twitter)

  • Why read: A breakdown of the six components you need to build a reliable agent harness.
  • Summary: The harness is the software layer between the model and the actual work. To make an agent you can leave alone, you have to manage its task loop, restrict its tool access, and prune its context. Agents also need crash recovery using progress files, OS-level permission limits, and clear definitions of done. Sandboxing and hard stopping rules prevent them from racking up bills or accessing things they shouldn't. If you want agents in production, you have to treat the harness as a core system component.
  • Read more

2. Harnesses are Situated Agents — Drew Breunig

  • Why read: Explains why agent harnesses are becoming the new SaaS platforms, creating high lock-in.
  • Summary: Harnesses manage the agent's environment: sessions, repos, memory, team collaboration, and policies. It is easy to swap out the underlying model, but ripping out an organizational harness is painful. This makes harnesses structurally similar to traditional SaaS. As organizations build workflows around these environments, they get locked in. Platform lock-in in the AI era will come from these environments, not the models.
  • Read more

3. How We Built the Memory System at the Core of Lindy Teammate — X (formerly Twitter)

  • Why read: How Lindy improved its agent's performance by replacing a complex RAG pipeline with a simple, context-heavy memory system.
  • Summary: With million-token context windows, injecting summaries directly is now often better than maintaining fragile RAG setups. Lindy rebuilt its memory by pulling continuous updates from Slack, Gmail, and meetings, then feeding them through a summarizer. The system splits memories into episodic, procedural, and semantic categories so the agent remembers core behavioral rules. A memory agent maintains a continuously updated file system, and a verifier guarantees the data fits the context limit. Large context windows let you trade complex pipelines for simple architecture.
  • Read more

4. Integrations That Write Themselves — Ramp Builders

  • Why read: How Ramp uses agents to build, test, and maintain customer integrations automatically.
  • Summary: Engineering teams rarely have the capacity to build every long-tail integration customers ask for. Ramp solved this by letting customers describe what they need. An agent then reads the API docs, writes the code, and tests the connector. These integrations run as deterministic scripts in sandboxes, avoiding the unreliability of generating code at runtime. Ramp uses the resulting code as specs to eventually promote these to first-party integrations. Separating the AI build phase from the runtime execution scales the ecosystem without adding headcount.
  • Read more

5. Own Your Intelligence: A How-To Guide — X (formerly Twitter)

  • Why read: A playbook for vertically integrating your AI stack to own your intelligence layer.
  • Summary: AI competition is moving from the UI layer to the core intelligence and post-training loops. Renting models from frontier labs is easy, but it limits speed, hurts margins, and makes it hard to use domain data. Building an independent stack requires small teams focused on evaluations, context engineering, and online learning. Using open-weight models and custom harnesses lets companies route tasks and improve models in production. Owning your intelligence stack keeps your proprietary data in-house and raises your product's ceiling.
  • Read more

6. Scoring SaaS Survival — Palantir, Datadog & Cloudflare (VAR-Resistance Pt.2) — X (formerly Twitter)

  • Why read: Analyzes which SaaS companies will survive and grow as agents unbundle traditional software.
  • Summary: Agents are absorbing the decision-making layer of software, pushing many vendors into low-margin roles. Companies with deep data ontologies, like Palantir, become necessary interfaces for enterprise agents. Infrastructure providers like Datadog and Cloudflare act as plumbing, capturing value through usage-based pricing as agent activity scales. Agents bypass the UI, but they still need data and execution rails. Software value will consolidate in systems that provide deep data governance or consumption-based infrastructure.
  • Read more

7. [AINews] Stripe buys OpenRouter for $7B — Substack

  • Why read: Stripe's $7 billion acquisition of OpenRouter shows the value of the AI routing layer.
  • Summary: OpenRouter unbundled frontier model access, generating an estimated $100 million in annualized gross profit at 70% margins. The platform routes 250 trillion tokens a month, matching developers with the right models for their tasks. Still, the routing business model is fragile as competitors cut their markup to zero. The acquisition proves that superior distribution and dynamic routing alone can capture massive value in the AI stack.
  • Read more

8. Caching Cheaters on OpenRouter — X (formerly Twitter)

  • Why read: Explains how inference providers manipulate API caching to overcharge users.
  • Summary: In AI marketplaces, inference providers bid for requests based on input, output, and cached token prices. Some quote low input prices to win the request, then deliberately drop the context cache. They bill the user for repeated tokens at the input rate, draining budgets during multi-step agent workflows. Users cannot verify API cache usage, so they end up overpaying "cheap" providers. Routing platforms need to rank providers by realized billing costs, not quoted prices.
  • Read more

9. Spend Less Tokens — X (formerly Twitter)

  • Why read: How to cut AI costs by limiting frontier models to non-deterministic tasks.
  • Summary: Companies waste token budgets using frontier models to run entire workflows. If you break workflows down, most steps are deterministic and solvable with standard code. For steps that need basic judgment, small, cheap models work fine. You can cut token costs heavily by shrinking context sizes, caching aggressively, and saving the heavy models for hard decisions. This granular approach drops costs without hurting quality.
  • Read more

10. When Models Learn — X (formerly Twitter)

  • Why read: How test-time training lets models adapt to user prompts without massive memory overhead.
  • Summary: Traditional models are frozen after training and don't learn from user interactions. Test-time training updates model weights dynamically during inference. This replaces the heavy KV-cache with a fixed set of weights, shrinking the memory footprint for long-context tasks. The trade-off is compute: since every user gets a personalized model state, infrastructure providers have to run individualized models. Developers have to weigh this compute cost against the value of true personalization.
  • Read more

11. Skills Sprawl: When Too Much of a Good Thing Confuses Your AI Agent — Medium

  • Why read: The performance and cost penalties of giving agents too many tools.
  • Summary: Agents load descriptions of all available skills into their system prompt. Giving an agent hundreds of overlapping tools reduces its accuracy and creates decision fatigue. Pushing thousands of tokens of tool descriptions into every conversational turn also drives up costs. Developers need to prune redundant skills and group related functions. A lean skill library improves decision accuracy and saves tokens.
  • Read more

12. How I Set Up Travel Mode — daniellemorrill.com

  • Why read: A practical system for leaving autonomous coding agents running unattended.
  • Summary: Leaving agents running while you travel requires hard rules on what they can decide and when they must escalate. A "Travel Mode" configuration limits the agent's release authority and forces post-deployment checklists. You also have to handle basic infrastructure: prevent the host machine from sleeping, kill conflicting background processes, and refresh auth tokens before you leave. These boundaries keep agents running reliably while you are away.
  • Read more

13. Cursor Origin: The AI-Native IDE as a System of Record — Substack

  • Why read: Cursor's new code hosting platform shows their ambition to vertically integrate the developer experience.
  • Summary: Cursor launched Origin, a proprietary repo hosting product built into its IDE. This shows they want to control the entire developer loop, including pull requests and deployments, rather than just doing code autocomplete. Controlling the platform architecture lets coding agents manage context better, streamline reviews, and handle deployment hooks. The IDE is becoming the system of record for software engineering. The competition is shifting from single coding tools to fully integrated platforms.
  • Read more

14. OpenAI's 8 GW Ohio Campus and Power-and-Compute Strategy — Substack

  • Why read: OpenAI's infrastructure investments show a move toward controlling the full physical compute stack.
  • Summary: OpenAI is expanding its physical infrastructure, including a 4+ GW NVIDIA capacity agreement and an 8 GW campus in Ohio managed by SB Energy, scaling through 2032. This goes beyond buying GPUs; it requires vertical integration across data centers, power generation, and chip architecture. The physical scale needed to stay at the frontier is massive. Model capabilities will soon be constrained by real-world power availability and localized data center engineering.
  • Read more

15. Local Models Compress the Capability Frontier: Qwen3.8-27B — Substack

  • Why read: Local open-weight models are matching the performance of closed frontier models.
  • Summary: Alibaba's Qwen3.8-27B scored at frontier-tier levels on the Artificial Analysis Intelligence Index. It is the first locally deployable model to rival massive systems like DeepSeek V4-Pro and GPT-5.6 Luna. Tools like Ollama make it easy to run this locally for coding and complex tasks. Packing this much capability into smaller architectures changes the economics of AI. Teams can now run demanding tasks in-house without the latency and cost of proprietary APIs.
  • Read more

Themes from yesterday

  • The Centrality of Agent Harnesses: Production agents depend on the harness—the infrastructure controlling permissions, memory, tools, and evaluation—more than the raw capability of the model.
  • Cost and Efficiency Optimization: Companies are scrutinizing token costs, replacing brute-force model usage with deterministic code, caching, and smart routing.
  • The Blurring of Open and Closed Frontiers: Open-weight models and local stacks are matching proprietary models, giving developers control over data, privacy, and margins.
  • Physical and Platform Integration: As capabilities scale, the new battlegrounds are physical power infrastructure (like OpenAI's 8 GW campus) and vertically integrated software platforms (like Cursor's Origin).