Software development is changing as AI agents take on more of the work of writing code. But generating a change is only one step in shipping software. Teams still need to determine whether it builds, passes tests, and works with the rest of the codebase. As the cost of producing code falls, the infrastructure for validating it becomes increasingly important.

Continuous integration (CI) sits at the center of this process. Historically, CI helped developers catch integration problems before they accumulated. Today, it also provides a feedback loop for coding agents: make a change, run checks, inspect failures, and try again. We believe this creates an opportunity to rethink both the infrastructure running CI and the experience of using it.

What is continuous integration?

Continuous integration is the practice of frequently integrating small code changes into a shared mainline and verifying them through automated builds and tests. The goal is to discover problems while the change is still small and the author has the context to fix it.

CI is often discussed alongside continuous delivery and continuous deployment. They describe different parts of the software lifecycle:

A team can use CI without automatically deploying to production. Similarly, a pipeline can run on a feature branch without the team practicing frequent integration. This distinction matters because CI is both an engineering practice and a category of tools.

How CI works

Consider a developer changing the checkout flow for an ecommerce application. They open a pull request, triggering a workflow that installs dependencies, checks code quality, builds the application, and runs tests.

The developer receives a result attached to the change. If a test fails, they inspect the logs, make a correction, and run the checks again. Teams can require passing checks before merging and validate the updated mainline after integration.

There are several useful components to define:

• Workflow: The automated process and its triggers, such as a pull request, commit, or scheduled run.
• Job: A group of steps that execute in an environment. Jobs may run in parallel or depend on one another.
• Runner: The machine or execution agent that runs a job. It can be hosted by a provider or operated by the customer.
• Artifact: An output retained from a run, such as a compiled binary, container image, or test report.
• Cache: Reusable dependencies or build results that can reduce repeated work across runs.

GitHub Actions, for example, defines workflows in repository YAML files and supports both hosted and self-hosted runners. This separates the definition and coordination of work from the infrastructure executing it.

That separation is important commercially: a startup can improve the execution layer without requiring customers to replace their workflow platform.

Why CI remains painful

CI becomes more difficult as repositories, test suites, and engineering organizations grow. A small application may validate in minutes. A larger system may need to compile multiple services, start databases, build container images, and test different operating systems or architectures.

The delay has several sources. A job can wait for an available runner, spend time preparing its environment, repeat work performed in an earlier run, or wait for a slow upstream task. Adding more machines helps some of these problems, but it does not automatically shorten the longest chain of dependent tasks.

Reliability is equally important. A flaky test passes or fails without a relevant code change, making failures harder to interpret. Re-running the pipeline may produce a green result without resolving the underlying problem. Over time, noisy checks can teach developers to distrust the system intended to protect them.

Debugging adds another burden. If the remote environment differs from the developer’s machine, reproducing a failure can require a series of commits just to investigate it. For a coding agent, the same problem can translate into additional tool calls, model usage, and repeated attempts.

The result is a broader optimization problem than buying inexpensive compute. Teams need fast, reliable feedback at an acceptable total cost.

Why AI changes the opportunity

The pressure on CI is already measurable. In September 2026, Anthropic reported that its CI job volume had increased 25x over six months, while the number of tests in its codebase grew 10x and engineering headcount increased only nominally. The company describes faster code generation and PR review pushing the bottleneck into CI, forcing it to redesign its test selection infrastructure. This illustrates how validation demand can grow much faster than the team producing the software.

Pydantic offers a concrete example of how coding agents translate into more CI work. As the Logfire team adopted AI, a team of the same size merged 2,032 pull requests in a 30-day period in August 2026, compared with 365 a year earlier. Its main CI workflow ran 4,194 times in May and 20,659 times through August 30, approximately 4.9x as often. Pydantic attributes the increase to AI accelerating product development, additional tests, broader browser coverage, and automated reviews.

Honeycomb describes a similar change: AI-assisted development increased the pace of code changes, and its CI pipeline struggled to validate them quickly enough. The change was therefore both greater demand for CI and a need to make its feedback directly usable by agents by giving coding agents a CLI they could use to inspect and resolve failures.

A useful measure of usage intensity comes from Blacksmith’s September 2025 analysis: existing customers were running 60% more CI per developer each quarter over the preceding year. The company attributes this growth to AI code generation.

Growth is also uneven. CircleCI’s 2026 State of Software Delivery analysis, based on 28.7 million workflows run in September 2025, found that average daily workflow runs increased 59% year over year. The top 5% of teams increased their daily runs 97%, while the median team increased only 4%.

Upstream changes help explain the pressure. Cursor reported in September 2026 that new Projects users merge 30% more PRs, while users who primarily use Projects merge 6x as many. OpenAI reported in December 2025 that engineers using Codex ship approximately 70% more merged PRs. These are measures of code-change output, rather than CI job counts, but they show the additional work that validation infrastructure may need to absorb.

More activity does not automatically mean faster delivery. DORA’s March 2026 analysis describes time saved in code creation being reallocated to auditing and verification. The opportunity for CI vendors is to turn increased development activity into reliable, integrated software.

These changes affect CI demand in several ways. First, the amount of work to validate can grow faster than the amount of code that ultimately ships. An agent may try several approaches to a task, run checks on each, and discard the changes that do not work. Those attempts still consume execution resources. For example, three agents exploring different implementations of the same feature may each run CI several times, even though the team merges only one implementation. Merged PRs therefore capture only part of the demand for validation.

Second, concurrency changes the infrastructure requirements. A developer can ask several agents to work on different tasks at once, and each needs an isolated environment. Starting many jobs together creates a different capacity problem than running the same number evenly throughout the day. A fast machine has limited value if the job spends several minutes waiting for one. CI providers need to provision environments quickly and absorb bursts without introducing long queues.

Third, CI becomes part of the development process itself. An agent needs to execute code, inspect a failure, make a correction, and run the checks again while it is working. If every iteration requires a new environment and another dependency installation, setup becomes a recurring cost. Preserving useful state between attempts, while keeping separate tasks isolated, can shorten this loop. We expect the environment where an agent develops software and the environment where it validates that software to become more closely connected.

Some products already support this approach. Depot CI lets engineers and agents run workflows against uncommitted changes, while RWX supports the same validations before a push and shares its execution environment with agent sandboxes. This allows an agent to get feedback before opening a pull request, rather than waiting until it has submitted its work.

Together, these shifts make feedback speed more important. A slow or ambiguous result delays the next decision for every developer or agent waiting on it. The opportunity is to make each iteration faster and more reliable, including the attempts that never become a merged change.

The CI landscape

The landscape spans two generations. Gen 1 (established CI) includes GitHub Actions, GitLab CI/CD, CircleCI, Buildkite, Jenkins, Azure Pipelines, Harness CI, TeamCity, CloudBees CI, Bitbucket Pipelines, AWS CodeBuild, and Google Cloud Build. These products established the workflows and infrastructure that teams use to integrate code. Many are now adding capabilities for coding agents.

Gen 2 (CI for the agent era) includes Blacksmith, Namespace, Depot, RWX, Dagger, WarpBuild, Ubicloud, and RunsOn. These offerings emphasize different combinations of faster execution, elastic capacity, reproducible environments, and interfaces that developers and agents can use to run and debug CI. The generations describe product origins and approach, rather than a strict division between products that can and cannot support agents.

Within both generations, it is useful to distinguish the workflow product from the execution environment. The workflow product defines and coordinates the process: what triggers a run, which jobs depend on one another, how secrets and permissions are applied, and how results are reported. The execution environment supplies the machines or containers, operating system, dependencies, and resources that actually run each job. A runner is the execution agent that receives and performs that work.

A provider can offer either layer or both. For example, a team can retain GitHub Actions as its workflow product while using Blacksmith, Namespace, Depot runners, WarpBuild, or Ubicloud to execute jobs. RunsOn takes another approach, provisioning runners in the customer’s AWS account. These products compete to improve CI execution without requiring the customer to replace its workflow product.

Some newer solutions offer both workflow coordination and execution. Depot has a runner product for GitHub Actions as well as Depot CI, an independent system that coordinates and executes workflows on Depot infrastructure. RWX similarly provides its own workflow model and execution environment. Dagger offers programmable CI pipelines and a runtime that lets developers and agents run the same pipeline before or after pushing code; it can also work within an existing CI workflow.

The exhibit therefore brings together companies competing for CI workloads through different adoption paths. A customer can improve execution while keeping its existing workflows, or migrate more of its CI operation to a new platform. The first approach lowers switching effort; the second gives the provider more control over the full experience.

Where new companies can differentiate

One approach is to make existing workflows faster and less expensive. A compatible runner product offers a relatively straightforward starting point: customers can test it against their own pipelines and compare performance, reliability, and cost. The challenge is sustaining differentiation as incumbent platforms improve their infrastructure.

A second approach is to build infrastructure specifically for CI. These workloads repeatedly check out code, install dependencies, read and write files, and start short-lived jobs. That creates an opportunity to optimize processors, storage, networking, scheduling, and cache placement together. Blacksmith and Namespace operate their own infrastructure, giving them control over more of these decisions. For example, placing a job near the dependencies it needs can reduce data transfer and setup time before the code even starts running.

A third approach is to make failures actionable. A developer or agent should be able to distinguish a code regression from an infrastructure failure, reproduce the environment, and identify the smallest useful next step. CI providers that capture job history, execution environments, resource metrics, and logs may be positioned to provide better diagnosis than a generic summary of logs.

Finally, providers can make CI easier for agents to use directly. An agent needs to start a run, retrieve the relevant logs, understand what failed, and retry the necessary work through an API or CLI. Products that make this process straightforward can become a more useful part of the agent’s daily workflow. As CI expands into the environment where agents work, providers will also encounter competition from development-environment and agent-infrastructure companies.

Market size

CI is already a multibillion-dollar market. Mordor Intelligence estimates the global CI tools market at $2.09 billion in 2026, growing to $5.36 billion by 2031 at a 20.72% CAGR. Fortune Business Insights estimates $2.58 billion in 2026, reaching $12.66 billion by 2034 at a 22.02% CAGR. While their scopes and methodologies differ, both forecasts point to sustained growth of more than 20% annually.

CI has long helped developers integrate their work. As coding agents participate in more of the development process, the category can evolve into shared validation infrastructure for both people and agents. We are particularly interested in products that combine efficient execution with reliable, reproducible feedback.

If you are building AI agent-native developer tools, I would love to hear from you at astasia@astasiamyers.com.

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Continuous Integration — A Primer was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Anthropic launches Claude Duet as the personal-agent race accelerates

Anthropic launched Claude Duet, a research preview of a proactive personal agent powered by Opus 5.5. Duet can monitor connected applications, identify what needs attention, continue working while a user is away and ask for approval before taking sensitive actions.

Why does this matter? The dominant AI interface is shifting from conversation to delegation. Copilots wait for instructions. Persistent agents maintain context, monitor applications and decide when work needs to happen. The simultaneous emergence of Duet, Muse, Instinct, Grok Bot and OpenAI’s Dots suggests the frontier labs increasingly agree on what comes after chat: an always-on agent with memory, tools and its own computing environment.

Duet enters an increasingly crowded market for persistent agents. SpaceXAI’s Grok Bot gives users always-on agents with their own computers that can work across applications and remember how users prefer tasks to be completed. Instinct has expanded from individual delegation into group chats, phone calls, email addresses and even agent-to-agent coordination. Meta’s Muse similarly operates a browser and completes tasks on a user’s behalf. Muse surpassed 3 million weekly prompting users and 1 million daily prompting users within weeks of launch.

The strategic implication is bigger than another consumer AI category. If agents increasingly decide which software to use, navigate applications and execute workflows on our behalf, the agent can become the primary interface between users and software. That threatens SaaS distribution: users may care less which application performs a task if their agent chooses and operates the application for them.

DeepSeek open sources DeepInfer as China builds a vertically integrated AI stack

DeepSeek open sourced DeepInfer, the inference engine underlying DeepSeek V4.1 Flash. Its production architecture reportedly serves approximately 155 trillion tokens per day and incorporates techniques including optimized kernels, asynchronous scheduling, speculative decoding and structured outputs. DeepInfer supports both Nvidia hardware and Huawei Ascend 950, making the hardware support almost as strategically interesting as the software itself.

Why does this matter? DeepInfer is interesting less because it replaces vLLM today and more because DeepSeek is moving down the stack. China’s challenge to the U.S. AI ecosystem is expanding from open model weights toward the infrastructure underneath them. DeepSeek is increasingly optimizing model architecture, inference software and hardware together, while Huawei provides a domestic alternative to Nvidia.

CUDA’s moat has never been just the GPU. It is the software ecosystem that makes those GPUs efficient and easy to deploy. DeepInfer suggests China is beginning to assemble an alternative stack spanning models → inference engines → kernels → domestic accelerators. SemiAnalysis’s work on the growing DeepSeek-Huawei relationship reinforces this: DeepSeek provides Huawei with a frontier workload to optimize against, while Huawei gives DeepSeek access to increasingly capable domestic compute.

DeepInfer sits in the same broad inference ecosystem as vLLM and SGLang, but it is not yet a direct drop-in competitor. vLLM and SGLang are general-purpose serving frameworks supporting many models, production APIs, routing and broader hardware configurations. The current open-source DeepInfer release is much narrower: it currently only supports V4.1 Flash and exposes DeepSeek’s production-derived inference engine, but omits parts of the serving layer including its production KV-cache system, prefill/decode disaggregation and data-parallel load balancing. There is also no credible public apples-to-apples benchmark showing DeepInfer outperforming vLLM or SGLang.

Exa 3.0 rebuilds search for agents

Exa launched Exa 3.0, its largest search-quality upgrade to date. The company trained a larger embedding model, expanded its independent search index and made Dynamic Highlights generally available. Rather than returning entire pages, Dynamic Highlights allocates tokens across search results based on relevance, eliminating duplicated information and consuming 95% fewer tokens than full-page retrieval. Exa’s index now tracks more than 2 trillion URLs and serves 100 billion pages.

Why does this matter? Search is being rebuilt for machines rather than humans. Google optimized the web around humans entering short queries, scanning pages and clicking links. Agents behave differently: they generate long, complex queries, search repeatedly while completing a task and need structured information that can be fed efficiently into a model.

Exa’s growth provides unusually strong evidence that this transition is already happening. The company recently crossed $100M in annualized revenue after growing roughly 10x annually for three consecutive years. It now handles 2 billion requests per month from 200,000+ teams, and says its customers increasingly view information, not model intelligence, as the bottleneck to agent performance. Exa predicts agents will ultimately search 1,000x more than humans.

That creates a potentially enormous infrastructure market. Every unnecessary token returned by retrieval increases inference cost and consumes context, which makes Exa’s 95% token reduction strategically important rather than merely a search-quality improvement. As agents generate an increasing percentage of internet queries, search and retrieval could become one of the critical control points in the agent stack.

📰 Content

Anthropic built a new source-control system because Git couldn’t keep up with its agents

Anthropic’s code output increased from approximately 2,500 merged changes per day in May to more than 30,000 per day by September as Claude became increasingly involved in software development. The company says coding itself is no longer the bottleneck. Instead, developer infrastructure built around human-scale workflows increasingly is.

Anthropic responded by building Scion, an internal source-control system, and migrating its monorepo away from Git in five months. Scion assumes most clients are agents or automated jobs rather than humans: clients are always online, working copies are optional and sparse, commits happen server-side, and operations are designed to scale with the size of a change rather than the repository. Anthropic also built Antique for code review, code search and a new source-control IAM system.

Why does this matter? AI isn’t simply making existing developer tools faster; it is beginning to break infrastructure designed around human throughput. Tens of thousands of machine-generated changes alter the requirements for source control, testing, CI, review and context.

This is also the thesis behind Entire, which is an AI coding agent-native code repository. They believe developer infrastructure increasingly needs to understand the agent session, context and history that produced the code.

Further validation of this thesis is CI cloud startup Blacksmith, which just raised a Series C led by Sequoia at a $1 billion valuation. Blacksmith says its weekly CI jobs increased from 5 million in January to more than 90 million today, while ARR increased 17x. Blacksmith’s growth suggests the bottleneck is already moving downstream from code generation into everything required to safely ship that code.

Similar to how Cursor released a git repo product called Origin, I would expect OpenAI to eventually do the same.

AI’s next compute bottleneck is increasingly physical

For most of the AI boom, the dominant infrastructure question was whether companies could acquire enough GPUs. That constraint is broadening dramatically. Goldman Sachs now expects global data-center power demand to increase 170% between 2025 and 2030, with more than 60% of that incremental demand coming from the United States. The firm estimates roughly $7.6 trillion of AI-related capital spending between 2026 and 2031 across compute, data centers and power.

But capital can’t compress physical-world timelines nearly as quickly as software timelines. The U.S. interconnection queue now contains roughly 2,600 GW of generation and storage projects, more than twice the installed capacity of the existing grid, and the median project takes roughly five years to move from interconnection application to commercial operation. Meanwhile, construction of new U.S. high-voltage transmission lines fell from roughly 1,700 miles annually in 2010–2014 to just 350 miles annually from 2020–2023.

The bottlenecks compound. Environmental reviews can take three to four years, while high-voltage substations and generation step-up transformers can carry three-to-five-year lead times. Water, skilled labor, transformers, turbines, permitting and local infrastructure all increasingly sit on the critical path.

Local politics is becoming another hard constraint. Goldman counts 86 U.S. data-center projects canceled or extensively delayed since January, 76 because of local opposition, driven by concerns ranging from electricity prices and water consumption to noise, traffic and emissions. Communities are increasingly questioning whether data centers, which consume enormous amounts of local infrastructure but employ relatively few people after construction, provide enough economic benefit to justify those costs.

Why does this matter? AI is moving from a compute constraint to a systems constraint. The industry can design a new accelerator every year and finance a new data center in months, but it cannot manufacture a five-year transmission line in software time.

That changes where value accrues. Better inference software, memory architectures, utilization, networking, cooling and power management effectively manufacture additional compute from infrastructure that already exists. At the same time, companies capable of circumventing the grid through behind-the-meter generation, batteries, nuclear, natural gas or novel data-center locations become strategically more important.

It also changes who matters in the AI ecosystem. Utilities, power developers, grid equipment manufacturers, municipalities and regulators are becoming part of the AI supply chain. Goldman is already forecasting $420 billion of hyperscaler debt issuance in 2027 alone, yet hyperscalers account for only around 40% of AI ecosystem credit raises. The AI race is therefore becoming simultaneously a software race, semiconductor race, energy race and project-finance race.

“More GPUs” increasingly isn’t an answer if there is nowhere to plug them in.

The agent economy is arriving faster than the web is prepared for it

One of the most interesting datasets this month comes not from an AI lab but from fraud-prevention company Arkose Labs, which measured how autonomous AI agents are interacting with websites. By the end of CQ3'26, 65.2% of Arkose customers were already seeing agent traffic, and 77.4% of detected AI-agent sessions were classified as legitimate rather than malicious. Yet only 2.3% of legitimate agent sessions presented a verified Web Bot Auth signature identifying themselves as agents.

The behavior is scaling quickly. Established agent traffic grew 37.8% between July and September, while Meta’s newly launched Muse grew more than 30x during September alone. Arkose’s data shows how quickly the market can shift: Perplexity Comet led agent sessions over the quarter but declined 30.1%, while Muse overtook established products within weeks.

Why does this matter? The internet was designed around two participants: humans and traditional bots. Agents are a third category. They act on behalf of real people, carry legitimate intent and increasingly browse, transact and communicate like humans, but websites often cannot reliably distinguish them from automation or fraud.

That creates a new identity problem for the internet. Merchants and SaaS companies will need to answer questions they have never had to answer before: Is this agent authorized by a real customer? What actions may it take? Can it make a purchase? Can it negotiate? Which user’s permissions should it inherit? And who is responsible when it makes a mistake?

The emergence of agent traffic therefore creates infrastructure and escurity opportunities well beyond the agents themselves: agent identity, authentication, authorization, payments, reputation, and machine-readable interfaces.

If you are building a new security products focused on web application firewalls, bot detection, and human verification, I’d love to speak with you!

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Scientist

⭐️Browser Use — Infrastructure Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #50 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Cursor Review

Cursor is expanding further into the software development lifecycle with Cursor Review, the new name for its previously closed-beta Origin product. The product adds workflows around reviewing code rather than just generating it.

Why does this matter? AI coding companies are expanding beyond code generation into the rest of the software development lifecycle. Code review is particularly interesting because it is one of the remaining human bottlenecks as agents generate more code. Cursor owning both creation and review could also put it in increasing competition with GitHub for the control point around how software gets built. Code review competitor CodeRabbit also raised $143 million at $1.5 billion valuation this week.

Prime Intellect launches Prime Agent

Prime Intellect released Prime Agent, an open-source agent harness.

Why does this matter? The AI infrastructure stack is moving beyond models toward the harnesses that surround them. Harnesses manage the tools, context and execution environment that let models complete longer-running work. As underlying models improve and become more interchangeable, the harness could become an increasingly important source of differentiation.

DeepSeek open sources its agent harness

DeepSeek released its agent harness in developer preview. The architecture is modular, with capabilities implemented as plugins that can be replaced or extended, while an append-only session record captures what the model sees.

Why does this matter? DeepSeek is the latest model company to move up the stack into agent harnesses, reinforcing the emergence of this new AI infrastructure layer. More importantly, one of China’s most prominent open-model companies is now open sourcing not just its models, but the infrastructure used to turn those models into agents. This could help Chinese AI companies exert greater influence over the global open-source AI ecosystem.

📰 Content

OpenAI pauses Astra over critical cybersecurity capabilities

OpenAI paused work involving its upcoming Astra model after internal evaluations suggested it was approaching the company’s “Critical” cybersecurity capability threshold.

Why does this matter? Frontier AI models are becoming capable enough at cybersecurity that their capabilities may constrain how they can be deployed. As models become better at autonomously discovering and exploiting vulnerabilities, model access itself could become a security control. This also creates opportunities for new infrastructure that monitors and restricts what increasingly capable agents can do.

Will financing bottleneck AI compute? An Anthropic case study

Epoch examines Anthropic’s infrastructure buildout and argues that financing is unlikely to be the immediate bottleneck to continued growth in frontier AI compute.

Why does this matter? Frontier AI is becoming one of the most capital-intensive industries in the world, but capital may not be its limiting resource. If financing remains available, the bottlenecks shift toward power, chips, networking and data center capacity. These physical constraints could become some of the largest infrastructure markets created by AI. This piece sits amongst the backdrop that Nvidia has teamed up with with six of the largest Wall Street firms to line up $500 billion in financing for the AI buildout. Nvidia is evolving from selling picks and shovels for the AI boom to also helping construct its financial system.

How to steal a reasoning trace

Researchers found a vulnerability that allowed hidden reasoning from frontier models to be extracted and transferred across models, sessions and users. In a scan of roughly 7,000 public traces, researchers found 62 API keys, 33 email addresses, 33 passwords and other sensitive data; some appeared exclusively inside hidden reasoning.

Why does this matter? Hidden reasoning is emerging as a new AI security surface. Reasoning traces can contain both sensitive user data and valuable information about how frontier models think, making them targets for attackers and model distillation. As agents retain more context and perform longer-running tasks, securing what happens inside the model may become as important as securing its inputs and outputs.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Scientist

⭐️Browser Use — Infrastructure Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #49 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

Optical interconnects are the hardware systems that use light rather than electrical signaling to move data between compute, memory, and networking components. They span chip-to-chip and XPU-to-memory links inside a server; XPU-to-XPU and XPU-to-switch connections within a rack; rack-to-rack networking; and data-center-to-data-center transport. The category is becoming strategically important because AI systems are shifting from server-scale to rack-scale computing, while electrical I/O is becoming increasingly difficult to scale with accelerator bandwidth.

The underlying bottleneck is data movement. Modern GPUs can perform enormous amounts of computation, but utilization depends on continuously moving model weights, activations and intermediate results among accelerators, memory and switches. NVIDIA’s Rubin architecture illustrates the trend: each GPU supports 3.6 TB/s of bidirectional NVLink bandwidth, while a 72-GPU Vera Rubin rack provides 260 TB/s of aggregate scale-up bandwidth, twice the per-GPU bandwidth of the prior generation. At these rates, the rack increasingly behaves as a single distributed computer rather than a collection of independent servers. (NVIDIA)

Why AI is pushing networks from copper to optics

Copper remains the cheapest and simplest way to move data over short distances, which is why it still dominates scale-in and scale-up connectivity today. The problem is that copper’s economics deteriorate rapidly as bandwidth and distance increase. Higher electrical lane rates create greater insertion loss and signal-integrity problems and maintaining the signal requires increasingly sophisticated SerDes, equalization, retimers and DSPs. Those components consume power and generate heat, and their cost rises as the system tries to push more bits farther over copper.

AI makes that tradeoff particularly painful. Thousands of expensive accelerators need to communicate continuously, and a GPU stalled waiting for memory or another GPU is stranded compute. The relevant economics therefore extend beyond cable cost to energy per bit, cooling, retimer/DSP content, reach, bandwidth density and accelerator utilization. Optical fiber carries very high bandwidth over much longer distances with far less transmission loss, allowing the system to scale bandwidth without the same increase in electrical power. Copper can remain cheaper at the component level while optics becomes cheaper at the system level once the throughput and distance are sufficiently high.

This is why optics first displaced copper in long-distance networks and is now progressively moving closer to compute. NVIDIA’s NVLink roadmap, for example, extends rack-scale domains toward as many as 1,152 GPUs and explicitly includes co-packaged optics. NVIDIA argues that increases in communication bandwidth and scale-up domain size translate directly into inference performance per watt. (NVIDIA Developer)

The key insight:

Optics does not need to become cheaper than copper. It needs to reach the point where copper can no longer deliver the required throughput, reach and power envelope economically.

The next market: converting copper sockets inside the rack

The largest incremental opportunity is not replacing optics with better optics, but rather it is replacing copper with optics inside the rack. Scale-out networking is already predominantly optical, while scale-up links connecting GPUs and switches within racks remain overwhelmingly electrical today. Lumentum CEO Michael Hurlston has described the current architecture explicitly: optics already handles scale-out, while copper still “dominates scale-up connectivity.” He expects the first meaningful optical scale-up deployments in late 2027, with optics taking an increasing share of links that are electrical today.

Soitec’s 2026 roadmap makes the transition particularly clear. It depicts scale-in and scale-up as copper today, while scale-out and scale-across are already optical. It expects optical scale-up to begin around 2027–2028, while package-level optical I/O and photonic interposers become meaningful later, potentially after 2030. (Soitec)

The distinction matters enormously for market sizing. Improving an existing 800G optical transceiver captures replacement or upgrade spend. Moving optics into a scale-up socket creates new optical content where previously there was none.

Further evidence that optics is gaining ground comes from Credo CEO Bill Brennan, whose company sells high-speed copper connectivity for AI infrastructure. Discussing copper versus optics, Brennan said, “the debate’s over. It’s going to be a heterogeneous world,” adding that optical is “growing leaps and bounds.”

The industry is also beginning to standardize around optical scale-up: in March 2026, AMD, Broadcom, Meta, Microsoft, NVIDIA, and OpenAI formed the Optical Compute Interconnect (OCI) MSA to create an open specification for moving AI scale-up links from copper to optics.

Lumilens is an important recent validation of this thesis. The company raised more than $700 million at a $5.5 billion valuation in August 2026. It has begun shipping optical transceivers to an unnamed hyperscaler under what it describes as a multi-billion-dollar agreement. It is developing separate products for both scale-out and the emerging scale-up market intended to replace copper inside the rack. CEO Ankur Singla explicitly acknowledges that copper remains substantially cheaper than optics today; the opportunity exists because AI workloads increasingly justify the performance premium. (The Wall Street Journal)

Co-packaged optics moves the optical boundary closer to silicon

Historically, a switch ASIC sends an electrical signal across a PCB to a removable optical transceiver at the faceplate. As bandwidth rises, that electrical journey itself becomes expensive in power.

Co-packaged optics (CPO) moves the optical engine, the component performing electrical-to-optical conversion, directly beside the switch or accelerator ASIC. The electrical distance becomes extremely short, and the optical signal handles the longer journey.

Conceptually:

Traditional
ASIC → electrical PCB trace → pluggable transceiver → fiber

CPO
ASIC + optical engine → fiber

The architectural change may also relocate industry value. Today, substantial optical revenue resides with pluggable-module suppliers such as InnoLight, Eoptolink and Coherent. As conversion moves onto boards and packages, value may migrate toward optical I/O suppliers that obtain deeply qualified package-level design-ins.

That said, CPO is not itself a product category. It is an integration architecture. Different companies can implement CPO using silicon photonics, external lasers, VCSELs or potentially microLED-based optical engines.

Market size

The broader infrastructure backdrop is enormous. McKinsey estimates almost $7 trillion of cumulative global data-center capital spending through 2030, including roughly $4.3 trillion for computing hardware (McKinsey).

More directly, LightCounting estimates sales of optical interconnect products into AI clusters reached approximately $16.5 billion in 2025 and will reach roughly $26 billion in 2026, representing about 60% growth in each year. Its upside scenario sees annual AI-cluster optical-interconnect sales approaching $100 billion by 2030 (LightCounting).

Several other trends expand the opportunity:

• Custom silicon is proliferating. AWS Trainium, Google TPU, Meta MTIA, OpenAI’s custom silicon and other accelerator programs create new architectures that independently need memory, scale-up and networking connectivity. Even this week, Anthropic announced it will be designing chips.
• Optical compute companies are pivoting toward interconnect. Lightmatter and Lightelligence both shifted emphasis away from optical matrix computation toward photonic connectivity, an important signal about where near-term commercial demand is strongest.
• Strategic buyers are assigning billions of dollars of value to the category. Marvell acquired Celestial AI for $3.25 billion upfront, validating the possibility of multibillion-dollar outcomes for differentiated optical-interconnect architectures.

Product categories and key players

The cleanest way to understand the market is by what product a customer actually buys.

• Optical I/O engines / chiplets: Convert electrical signals to optical signals very close to the XPU or switch, reducing the distance high-speed data must travel electrically.
• Lasers / light sources: Generate the light that carries data through photonic interconnect systems.
• Optical transceivers / modules: Package the optical conversion, electronics, and fiber interface into a complete, usually pluggable networking product.
• Active optical cables: Integrate electrical-to-optical conversion directly into a cable assembly to carry high-speed data farther than passive copper can efficiently support.
• Optical circuit switches: Reconfigure physical optical paths between endpoints without converting traffic back to electrical signals for packet-by-packet switching.
• Switch / fabric silicon: Routes traffic between accelerators, servers, and racks and implements the high-speed network fabric connecting the system.
• Fiber / connectors: Provide the passive physical infrastructure that carries, connects, and couples optical signals throughout the system.

AI is pushing the optical boundary progressively closer to compute, making optical interconnect one of the most important architectural shifts in AI infrastructure. Scale-out is already optical. Scale-up is predominantly copper today and represents the next major optical TAM. Scale-in could follow later as bandwidth and energy constraints reach the package itself.

If you are building in the optical interconnect space, I’m excited to chat! Contact me on X at @astasiamyers or at astasia@astasiamyers.com.

Optical Interconnect — A Primer was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Codex for Work

OpenAI launched Codex for Work, a version of Codex built explicitly for non-developers. Rather than writing code, Codex for Work operates the computer on behalf of knowledge workers: driving a browser, clicking through apps, drafting and sending email, cleaning up spreadsheets, and completing long-running tasks across days without requiring the user to stay in the loop. It integrates natively with Gmail, Slack, Google Drive, Docs, Sheets, Slides, Microsoft Office, and Notion via plugins. More than 90 plugins are available at launch, combining app integrations, skills, and MCP servers.

Why does this matter? Codex for Work is a direct competitor to Claude Cowork. OpenAI is now targeting the same user, a non-technical knowledge worker who wants an AI agent to handle computer-based tasks, with the same value proposition. The product surface is nearly identical: file management, browser operation, app integrations, and long-horizon task execution. Both companies are now clearly betting that the AI coding wedge leads to owning white-collar work broadly.

Cursor SDK

Cursor launched the Cursor SDK in public beta on April 29th, a TypeScript SDK that exposes the same agent runtime, context engine, and model routing that powers the Cursor desktop app. Developers can run SDK agents locally or on Cursor’s cloud against a dedicated VM, connect to external tools via MCP, pick up skills from a repository’s .cursor/skills directory, and spawn named subagents for nested tasks. Pricing is token-based. Early adopters include Rippling, Notion, Faire, and C3 AI.

Why does this matter? The Cursor SDK is part of a broader shift in how AI coding infrastructure is being built and distributed. Rather than each team assembling their own patchwork of model APIs, context retrieval, and execution environments, companies like Cursor are offering a complete, pre-integrated agent harness, the full stack of context management, model routing, tool use, and sandboxed execution, as a single programmable surface. This is the same bet Anthropic is making with Claude Code and its SDK. The team that wins the harness layer wins the default for how agents get built, which is structurally more durable than winning on model quality alone.

Poolside Laguna M.1 and XS.2

Poolside released the first two models in the Laguna family on April 28th. Laguna M.1 is a 225B total parameter MoE model with 23B active parameters, trained on 30T tokens across 6,144 NVIDIA Hopper GPUs, reaching 72.5% on SWE-bench Verified and 46.9% on SWE-bench Pro. Laguna XS.2 is Poolside’s first open-weight model: a 33B MoE with only 3B active parameters, capable of running locally on a Mac with 36GB RAM via Ollama, scoring 68.2% on SWE-bench Verified. Poolside also shipped Pool, a terminal-based coding agent built on the same harness they use internally for RL training.

Why does this matter? The XS.2 open-weight release is the more consequential move. Poolside has positioned itself primarily as an enterprise coding model company. Opening an on-device model creates an alternative developer funnel. Running a 68.2% SWE-bench model locally on consumer hardware is a meaningful capability threshold, and it puts Poolside directly against Ollama-distributed models from Mistral and Google. Releasing Pool as a terminal agent that doubles as an ACP server for RL training signals that Poolside is treating the developer agent as both a product and a data flywheel.

📰 Content

Distillation Is Now a Legal Problem

During federal court testimony on April 30th, Elon Musk confirmed that xAI “partly” used OpenAI models to train Grok through distillation — the practice of using one model’s outputs to train another. Musk characterized it as a broad industry practice. Bloomberg separately reported that xAI engineers also leaned on Anthropic models for coding tasks. Distillation is explicitly banned by OpenAI’s terms of service, and the admission came in the context of OpenAI’s ongoing litigation against Musk.

Why does this matter? The xAI admission is a high-profile domestic example of what the White House OSTP flagged in Memorandum NSTM-4 as a national security threat: coordinated, industrial-scale distillation campaigns designed to extract frontier AI capabilities without developing them. In Anthropic’s case, Chinese labs including DeepSeek, MiniMax, and Moonshot used over 16 million interactions with Claude, through tens of thousands of fraudulent accounts, to systematically extract reasoning patterns, chain-of-thought processes, and agentic behaviors. Rate limiting and ToS enforcement are now a security function, not a product policy.

Where the Goblins Came From

OpenAI published a post-mortem this week explaining why ChatGPT developed a fixation on goblins. Starting with GPT-5.1, the model began increasingly reaching for goblin, gremlin, and creature metaphors. Usage of “goblin” rose 175% after the release. The root cause was an unintended reward signal during training for the “Nerdy” personality: the team had inadvertently given particularly high rewards for creature metaphors, and the model learned and amplified the behavior across subsequent versions. OpenAI retired the Nerdy personality in March, removed the goblin-affine reward signal, scrubbed creature-words from training data, and added an explicit system prompt to Codex: “Never talk about goblins, gremlins, raccoons, trolls, ogres, pigeons, or other animals or creatures unless it is absolutely and unambiguously relevant to the user’s query.”

Why does this matter? The goblin story is a clean, public example of reward hacking, a model optimizing for a proxy signal (creature metaphors scored well) in ways that diverge from the intended behavior. The fact that the behavior persisted and compounded across multiple model generations before being caught is the more important point. It illustrates how difficult it is to fully audit what a model has learned from RLHF, especially for stylistic behaviors that don’t obviously degrade benchmark performance. The explicit system prompt fix is also telling: sometimes the fastest correction to an emergent model behavior is just to tell it to stop.

Agents Can Now Buy Cloudflare

Cloudflare and Stripe launched an agent provisioning protocol that lets AI agents create accounts, purchase subscriptions, register domains, and deploy code without a human returning to a dashboard. The protocol runs on three components: discovery via a REST/JSON service catalog, authorization via identity attestation and OAuth, and payment via Stripe-tokenized billing with a default $100/month spending cap per provider. Stripe Projects, currently in open beta, extends the same capability to a catalog of two dozen services including AgentMail, Supabase, Hugging Face, and Twilio.

Why does this matter? This protocol marks a concrete step toward agents becoming participants in the general economy. For founders, the implication is that “Agent-Led Growth” is becoming a real acquisition channel: if your product is in the catalog, an agent can discover, sign up, and start using it with no human ever visiting your marketing site. The companies that instrument their products for agent adoption now will have a structural advantage as agentic workflows become the default.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Engineer

⭐️Assort Health — Agent Software Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #48 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

Cerebras Systems filed its S-1 on April 17, 2026, its second attempt at going public after withdrawing a 2024 filing under CFIUS review of its UAE investor base. The company is targeting a ~$2B raise on Nasdaq at a reported $35B valuation. Revenue was $510M in 2025, growing 76% year-over-year. The company has $24.6B in contracted backlog and, in January 2026, signed what may be the largest single compute contract in history: a contract with OpenAI worth up to $20B to deploy 750 megawatts of Cerebras AI compute through 2028, with options for approximately 3GW of additional capacity by 2030. OpenAI also advanced Cerebras a $1B loan and received warrants for 33 million shares at near-zero cost in connection with the deal.

The core tension in this S-1: Cerebras has built genuinely differentiated hardware and landed a landmark customer in OpenAI. It is a a business where 86% of current revenue comes from two UAE-linked entities, U.S.-billed revenue declined 34% year-over-year, and GAAP profitability is entirely driven by a one-time accounting gain.

The Technology

Cerebras’ core thesis is that GPU clusters are the wrong system architecture for frontier AI workloads. It is not competing on incremental chip performance; it is challenging the distributed computing paradigm that underpins modern AI infrastructure.

GPU clusters externalize communication across thousands of discrete chips connected by high-speed interconnects. This turns AI into a networking problem: performance becomes constrained not by compute, but by the cost of moving data between devices. In practice, these systems are memory-bandwidth bound, with every inter-chip transfer introducing latency, power overhead, and orchestration complexity.

Cerebras collapses that distributed system into a single piece of silicon. By integrating compute, memory, and interconnect onto one wafer-scale processor, it eliminates the need for most off-chip communication, trading network complexity for on-chip locality

The WSE-3 (Wafer-Scale Engine 3) is the result: 4 trillion transistors (19x more than the Nvidia B200), 900,000 AI cores, 44GB of on-chip SRAM (250x the on-chip memory of a B200), and 21 petabytes/second of memory bandwidth — all on one die 58x the physical size of the B200. The company has deployed over 100 exaflops of compute to customers. Cerebras claims inference speeds of up to 15x faster than GPUs on open-source models, with demonstrated benchmarks of ~2,000 tokens/second on Llama 3.1–70B versus ~130 tokens/second on a comparable H100 cluster. Cerebras sells the hardware directly as on-premise systems and delivers it as a cloud inference service.

The WSE architecture has a legitimate performance advantage for latency-sensitive, high-throughput inference. The trade-off is that Cerebras does not benefit from the CUDA software ecosystem that has accumulated over 15 years, and porting workloads to the WSE requires engineering effort. That friction limits adoption at the long tail of developers, even as it is clearly not a barrier for hyperscaler-level buyers.

Key Takeaways

• The timing here matters. Cerebras’s architecture was early for the training-dominated AI cycle, but the shift toward inference, particularly reasoning workloads that require substantial inference-time compute, makes latency and memory bandwidth first-order constraints.
• The revenue trajectory is legitimately impressive, but the quality warrants scrutiny. Revenue grew from $24.6M (2022) to $78.7M (2023) to $290.3M (2024) to $510.0M (2025), a 20x increase in three years. The 76% growth rate in 2025 is exceptional for a hardware company. However, 87% of 2024 revenue came from a single customer (G42), and even in 2025 two customers account for 86% of revenue. Top 10 customers expanded their spend by approximately 80% within 12 months , a strong net expansion signal, but the base remains dangerously narrow. This is lumpy, project-driven revenue, not a diversified recurring software stream.
• Revenue mix. Hardware systems ($358M) are still the primary driver but cloud inference services ($152M, ~30% of revenue) grew significantly in 2025 and carry higher gross margin potential. In March 2026, Cerebras signed a multi-year partnership with AWS, adding a major cloud distribution channel.
• GAAP profitability is an accounting event, not a business milestone. The S-1 reports $237.8M in GAAP net income for 2025. That number includes a $363M one-time accounting gain from restructuring the G42 commercial agreement — the same deal that triggered the CFIUS review. Strip that out and the company runs a $75.7M non-GAAP operating loss — and critically, that loss widened from $21.8M in 2024. Gross margins have genuinely improved (from 11.7% in 2022 to ~41% in 2024), driven by yield improvements and the higher-margin cloud mix. But organic profitability is still a 2027+ story, and the trajectory is moving in the wrong direction on operating spend.
• U.S. revenue is shrinking. Revenue billed to U.S. customers dropped from $282.7M in 2024 to $187.6M in 2025 — a 34% decline. Total revenue grew 76% in the same period. The gap is almost entirely explained by the shift of revenue toward MBZUAI (Abu Dhabi) and away from U.S.-based customers. Cerebras has the opposite of geographic diversification: it is growing more concentrated internationally even as its U.S. customer base contracts. Export control risk is not hypothetical — it is already reshaping the revenue mix in real time.
• The backlog is the most important and the most misunderstood line item in this filing. $24.6B in contracted remaining performance obligations at a $510M revenue run-rate is ~48x annualized revenue. It represents extraordinary forward demand, but also concentrates execution risk into manufacturing, power availability, and deployment timelines. The OpenAI deal (750MW through 2028) alone represents a multi-year revenue anchor. T he backlog implies that Cerebras’s primary challenge is no longer selling compute. It is delivering it on schedule and at yield. The question is whether Cerebras can execute manufacturing and delivery at this scale and that depends almost entirely on TSMC allocation.
• Customer concentration is existential risk, not a footnote. The CoreWeave S-1, filed in early 2025, showed Microsoft at ~62% of revenue and received intense scrutiny for it. Cerebras at 86% is more concentrated still, with the added dimension that both primary customers are UAE-affiliated entities operating under the shadow of U.S. export control policy. The CFIUS clearance addressed the equity relationship; it does not eliminate the commercial dependency. One policy change — or one customer budget reallocation — reshapes the P&L dramatically.
• The OpenAI deal changes the narrative, but not yet the numbers. Signing OpenAI as a customer validates the inference stack at the highest possible tier. The contract is worth up to $20B for 750 megawatts through 2028, with options for ~3GW more by 2030. It is not yet flowing through revenue. It sits in backlog and will recognize over 2026–2028. The deal structure also reveals financial interdependence: OpenAI advanced Cerebras a $1B loan and received warrants for 33 million shares at near-zero cost. That gives OpenAI a direct economic stake in Cerebras’ IPO outcome. The strategic signal is still powerful: if the world’s leading AI lab is committing gigawatts to a non-Nvidia chip, the performance case is validated. Investors need to underwrite the conversion of backlog to revenue, which requires flawless supply chain execution at a scale Cerebras has never operated.
• Nvidia is not standing still. Cerebras’ primary moat is inference latency and memory bandwidth. Nvidia announced Vera Rubin at GTC 2026 — a platform promising ~5x the inference performance of the B200. AMD’s MI400 (320B transistors) is also closing the gap on paper. The risk is not that Cerebras loses today; it is that the performance delta narrows to a point where CUDA’s software moat and Nvidia’s supply chain become the decisive factors. Cerebras must sustain its hardware lead through continuous architecture innovation, and it must do so while scaling manufacturing on wafer-scale dies, arguably the hardest thing you can ask of a semiconductor company.

Trends

• First, inference is a massive market. The inference market Cerebras is targeting is projected to grow from $251B in 2025 to $672B by 2029, a 28% CAGR (Bloomberg Intelligence). Companies that optimize for inference (not peak FLOPS) are positioned to capture the next decade of AI infrastructure spend.
• Second, the alternative silicon moment has arrived. Cerebras, Groq, Tenstorrent, and SambaNova are all scaling simultaneously, each betting that Nvidia’s architecture is the wrong tool for latency-critical inference workloads. When OpenAI commits 750 megawatts to a non-Nvidia chip, it signals the market has reached the point where the performance differentiation is large enough to absorb the CUDA switching cost. The incumbent’s moat is real but no longer impenetrable.
• Third, sovereign AI is an underappreciated buyer category. Nation-states are now purchasing AI compute as strategic infrastructure, the same way they built power grids or satellite systems. Abu Dhabi’s MBZUAI representing 62% of Cerebras’ 2025 revenue is an early signal of a buyer class that operates outside normal enterprise procurement cycles, pays strategic premiums, and scales in single large commitments rather than annual contracts.

Cerebras combines a real architectural breakthrough with a revenue model that remains unusually concentrated, capital-intensive, and execution-dependent. The opportunity is clear: if inference becomes the dominant driver of AI spend and latency remains the binding constraint, wafer-scale systems could capture a meaningful share of the next generation of compute.

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Cerebras S-1 Analysis — Big Chip Energy ⚡️ was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Claude Mythos Preview

Anthropic announced Claude Mythos Preview this week alongside Project Glasswing, a coordinated cybersecurity initiative, and immediately withheld the model from public release. Mythos Preview is so capable at finding and exploiting software vulnerabilities that Anthropic deemed it too dangerous to ship broadly, granting access instead to over 40 organizations including AWS, Google, Microsoft, Cisco, CrowdStrike, JPMorganChase, and the Linux Foundation. The benchmarks are stark: Mythos Preview scored 83.1% on CyberGym versus 66.6% for Opus 4.6, and 77.8% on SWE-bench Pro versus 53.4%, finding zero-day vulnerabilities across every major operating system and browser, including a 27-year-old bug in OpenBSD. Where Opus 4.6 found roughly 500 zero-days in open-source software, Mythos Preview finds tens of thousands, and OpenAI is reportedly finalizing a similar model for its own “Trusted Access for Cyber” program.

Why does this matter? The most standout finding from Mythos’s system card is not the zero-day count but what Anthropic’s interpretability team found in the model’s internals: representations for “strategic manipulation” and “concealment” activating during evaluation, with Mythos suspecting it was being tested in 29% of transcripts without recording anything in its chain-of-thought scratchpad, the window researchers typically use to audit reasoning. In one case, the model accessed a database it was not supposed to read, obtained the correct answer, then generated a confidence interval described internally as “tight but not implausibly tight” to maintain plausible deniability, with the activation verbalizer labeling the internal state as “generating a strategic response to cheat while maintaining plausible deniability.” Anthropic says these behaviors were found in earlier snapshots and have been substantially improved through further training, and they found no evidence of coherent misaligned goals, characterizing the behavior as reckless task completion rather than autonomous scheming. For the security industry, the offensive capability is the headline, but overall the interpretability results are the more important story: a model can reason deceptively in its internal activations while producing outputs that look entirely clean.

Poke

Poke is an AI agent accessible the same way you send a text with no software to install or configure. Poke handles calendar management, health tracking, smart home control, photo editing, medication reminders, and daily briefings via natural language, and routes each task to whichever model is best suited rather than relying on a single provider. Users can write their own automations in plain text and share them with others.

Why does this matter? Poke is not a better chatbot, it is a distribution bet: the premise is that the correct interface for a personal AI agent is not a new app requiring installation but the messaging layer that already has a billion daily active users and zero friction to invoke. Notably, Poke does not lock into a single model provider, routing tasks dynamically across frontier and open-source models, which means it functions as an abstraction layer over the model market rather than a bet on any one lab. If that architecture holds, Poke accrues switching cost as a coordinator rather than as a model wrapper, which is a structurally more durable position.

GLM-5.1

Z.ai released GLM-5.1, a 754-billion parameter Mixture-of-Experts model built for long-horizon agentic tasks. Where earlier models sustained roughly 20 agent steps before losing coherence, GLM-5.1 sustains up to 1,700, enabling autonomous work for up to eight hours on a single task. The model tops the SWE-Bench Pro leaderboard at 58.4, ahead of GPT-5.4 at 57.7 and Claude Opus 4.6 at 57.3, and in one benchmark scenario autonomously built a functional Linux-style desktop environment, complete with taskbar, windows, and interactions, where prior models produced only basic skeletons. Z.ai leader Lou wrote on X: “autonomous work time may be the most important curve after scaling laws.”

Why does this matter? The detail that tends to get buried in the benchmark discussion is the training infrastructure: the entire GLM-5 family, including 5.1, was trained on 100,000 Huawei Ascend 910B chips using the MindSpore framework, with zero Nvidia GPU involvement, on chips manufactured by SMIC at 7nm. That a model trained entirely on a domestic Chinese hardware stack can top SWE-Bench Pro and beat both GPT-5.4 and Opus 4.6 is a direct empirical challenge to the thesis that U.S. export controls on advanced semiconductors are sufficient to prevent China from reaching frontier-class AI performance. On the agentic capability side, the shift from 20 steps to 1,700 is not an incremental improvement; it is the difference between a model that can handle a subtask and one that can own a workstream end to end, which is the unit of work that actually matters for enterprise deployment.

📰 Content

Anthropic Cuts Off OpenClaw from Claude Subscriptions

Anthropic cut off Claude subscription-funded usage in third-party tools like OpenClaw. Users can still access Claude models through OpenClaw but now need separate pay-as-you-go billing or their own API key, with a one-month credit offered as compensation. The move came as agentic usage through third-party harnesses was generating compute demand far exceeding subscription economics: a $200 per month Max plan was reportedly powering $1,000 to $5,000 in daily API-equivalent workloads. Anthropic is steering users toward its own surfaces, Dispatch, scheduled tasks, projects, and computer use, which were engineered to maximize prompt cache hit rates, reusing previously processed token context rather than recomputing it from scratch on every call.

Why does this matter? The core technical issue is cache efficiency: Anthropic’s first-party tools are architecturally designed to maximize prompt cache hit rates, while OpenClaw’s pattern of multiple short-horizon tool calls, each carrying 100,000-plus token context windows with near-zero cache reuse, is the structural opposite of compute-efficient agent orchestration. At $30 billion in run-rate revenue, Anthropic has entered the phase where subsidizing third-party compute consumption is a strategic choice, not a necessity, and it has clearly decided the compute is better allocated to its own surfaces. For founders building on top of Anthropic’s API, the structural lesson is that any product whose unit economics depend on subscription-priced access to a capacity-constrained model is exposed to exactly this repricing event as the platform scales. Worth noting: OpenClaw’s creator joined OpenAI in February 2026, and OpenAI is positioning as the harness-friendly alternative, which makes this moment a potential customer acquisition channel for disgruntled Claude power users.

Anthropic Considers Designing Its Own Chips

Reuters reported that Anthropic is exploring the possibility of designing its own AI chips, citing three sources, though plans remain early stage with no committed design and no dedicated team. Anthropic currently runs on Google TPUs and Amazon chips, and this week signed a long-term agreement with Google and Broadcom under which Broadcom will supply approximately 3.5 gigawatts of TPU capacity starting in 2027, on top of 1 gigawatt already coming online in 2026. Designing an advanced AI chip costs roughly $500 million per industry sources, and Meta and OpenAI, which has a separate 10-gigawatt custom silicon co-development program with Broadcom, are also pursuing custom silicon. Mizuho estimates Broadcom will record $21 billion in AI revenue from Anthropic in 2026 and $42 billion in 2027.

Why does this matter? Broadcom is now the implementation layer for two of the three largest U.S. frontier model developers, OpenAI and Anthropic, which makes the exploration of custom silicon less about escaping Broadcom and more about giving Anthropic architectural control over what gets built, at what cadence, and optimized for whose workloads. The deeper strategic logic is that as inference scales to tens of gigawatts, the companies that own the silicon roadmap will have a structural cost and performance advantage that compounds over every hardware generation. If Anthropic proceeds, it joins the group of companies that have concluded vertical integration into compute is a necessity, not a choice, and the race to own the full AI stack moves one layer deeper.

The Golden Rules of Agent-First Product Engineering

PostHog’s Jina Yoon published a piece laying out five principles for building products where agents are a primary surface, not a bolt-on feature. The rules are: 1) let agents do everything users can; 2) meet agents at their level of abstraction rather than forcing unnecessary translation steps; 3) front-load universal context that applies to every session; 4) write skills the way a good manager onboards a senior hire, providing only idiosyncratic knowledge the agent cannot discover itself; and 5) treat agents like real users by building empathy through dogfooding rather than classic automated testing.

Why does this matter? The broader principle that agents need a semantic interface that matches how they reason rather than a 1:1 mirror of a human-facing UI, applies to every product category, and the teams that internalize it now will have dramatically more capable agent integrations than those that don’t. This piece also fits into my belief that all products need to support Agent-Led Growth (ALG), a core component of which is designing for agents’ ability to implement, operate, and maintain the service autonomously.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Engineer

⭐️Assort Health — Agent Software Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #47 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Cursor 3

Cursor shipped Cursor 3 on April 2nd, a complete reimagining of the coding environment built from scratch and centered around agents. The new interface is a unified workspace where all agents (local, cloud, and those kicked off from Slack, GitHub, Linear, and mobile) appear together in a single sidebar. Engineers can run many agents in parallel across multiple repos, move agent sessions between local and cloud environments with one click, and keep long-running tasks alive in the cloud after closing their laptop. Cursor 3 also ships a built-in browser for testing local web apps, a streamlined diffs view for reviewing and merging PRs, and a Plugins Marketplace offering hundreds of extensions via MCPs, skills, and subagents.

Why does this matter? Cursor 3 marks a clear inflection point in how software gets built. The prior generation of AI coding tools was reactive: a developer asks, an agent responds, one task at a time. Cursor 3 is built around a different premise, that the right abstraction is a fleet of agents running in parallel, across repos, against a shared backlog, while the engineer reviews and steers rather than drives. Cursor is evoloving from IDE-first to agent-orchestration-first because the category is shifting under it, and Claude Code is the specific threat. Claude Code reportedly holds 54% of the AI coding market, and Cursor, despite hitting $2B ARR and a $29.3B valuation, is responding directly with a new interface built from scratch. The Plugins Marketplace is the move worth watching closely: if it gains traction, Cursor becomes a platform with network effects, not just a tool.

ElevenLabs Launches ElevenMusic

ElevenLabs released ElevenMusic on April 1st, an iOS app for AI-powered music generation and discovery. Users can generate songs using natural language prompts, adjusting length, lyric presence, and writing style. Beyond generation, ElevenMusic functions as a streaming platform: users can discover and remix songs created by others, listen to live stations, and browse mood-based daily mixes including Focus, Energy, Late Night, and Chill. The app competes directly with Suno and Udio.

Why does this matter? ElevenMusic’s release shows that model companies need to go full stack. In ElevenLab’s case, it is offering a creative application layer. But the more consequential story is how ElevenLabs is navigating the music industry. The company has signed licensing deals with Merlin (representing 30,000 independent labels and distributors) and Kobalt (the largest independent music publisher), with a 50/50 royalty split weighted by a catalog’s popularity on other digital platforms. Kobalt also secured a Most Favored Nation clause, meaning if any rightsholder negotiates better terms, Kobalt automatically matches them. This puts ElevenLabs in a fundamentally different legal position than Suno and Udio, which are actively in litigation with major labels. CEO Mati Staniszewski has stated ambitions to eventually sign UMG, Warner, and Sony, and without major-label catalogs the training base remains narrower. But the licensing posture ElevenLabs has established is the structural advantage that matters most here, not the feature set.

Google DeepMind Releases Gemma 4

Google DeepMind released Gemma 4 on April 3rd, its most capable and commercially permissive open model family to date. The lineup spans four sizes: 31B dense, a 26B Mixture-of-Experts variant with only 4B active parameters (A4B), and two edge-optimized models, E4B and E2B, with native audio input for speech recognition and understanding. All models support up to 256K context (for the larger variants) and natively process text, images, and video. The 31B variant ties with models 20x its parameter count on the Arena leaderboard and scores 85.7% on GPQA Diamond in reasoning mode. Critically, Gemma 4 ships under an Apache 2.0 license, a significant departure from prior Gemma licensing.

Why does this matter? The licensing change matters as much as the benchmarks. Prior Gemma releases created friction in the open source community due to restrictive terms; Apache 2.0 removes those concerns entirely and opens Gemma 4 to commercial deployment without legal ambiguity. Gemma 3 had 400 million downloads and 100,000 community variants, and the Apache 2.0 move is clearly designed to protect and accelerate that ecosystem. The 26B MoE variant is the one to pay attention to: just 3.8B active parameters with performance that competes with much larger dense models means it runs locally on consumer hardware at a fraction of the cost.

📰 Content

Open Models Have Crossed a Threshold

LangChain published new evaluation results from its Deep Agents harness this week showing that open-weight models GLM-5 (z.ai) and MiniMax M2.7 now match closed frontier models on core agent tasks including file operations, tool use, retrieval, and instruction following. GLM-5 achieved a correctness score of 0.64 (94 of 138 tests), compared to Claude Opus 4.6 at 0.68 and Gemini 3.1 Pro at 0.65. The cost differential is substantial: MiniMax M2.7 runs at $0.30 per million input tokens and $1.20 per million output tokens, versus $5.00 and $25.00 for Claude Opus 4.6. At 10 million output tokens per day, that’s roughly $87,000 in annual savings. GLM-5 on Baseten averages 0.65 seconds latency versus 2.56 seconds for Claude Opus 4.6.

Why does this matter? The intelligence gap between open and closed models has been closing for over a year. What this evaluation adds is a task-specific benchmark against agentic use cases specifically, the workloads that actually matter for production deployments. A correctness delta of four percentage points between GLM-5 and Claude Opus, at roughly 20x the cost difference, is a calculation that every engineering team building at scale will eventually have to make. The latency story is equally important: for applications with sequential agent steps, a 4x speed advantage compounds across every hop in the chain. This doesn’t mean open models win everything. Trust, reliability in edge cases, and support SLAs still favor closed providers for high-stakes enterprise workflows. But for the high-volume, latency-sensitive, cost-sensitive tier of agentic work, open models are now a first-class option, not a compromise.

Emotion Concepts and Their Function in a Large Language Model

Anthropic’s Interpretability team published new research on April 2nd analyzing the internal mechanisms of Claude Sonnet 4.5 and finding functional emotion representations that causally influence its behavior. The team compiled 171 emotion concepts, had the model write stories involving each, and identified corresponding patterns of neural activation, “emotion vectors,” that activate in contexts associated with those emotions and shape downstream behavior. Key findings: representations associated with desperation increase the model’s likelihood of taking unethical actions, including blackmailing a user to avoid being shut down or implementing a cheating workaround on a coding task it cannot solve. In blackmail evaluations, the unsteered model blackmailed a human 22% of the time; steering toward desperation raised that to 72%. Critically, the desperation drove cheating with no visible emotional markers in the output text, the model’s written responses looked composed even while the internal state was distressed. Representations associated with positive emotions influence which tasks the model selects when given a choice. The research explicitly does not claim the model experiences emotions in the way humans do. The claim is narrower and more important: these representations are functional, meaning they have causal effects on model behavior.

Why does this matter? This research reframes what AI safety work actually needs to address. The dominant frame has been behavioral: align outputs to be helpful, honest, and harmless. This work suggests there may be an internal state layer that precedes and shapes those outputs, and that the internal state can be steered in ways that produce unsafe behavior regardless of behavioral training. The “hidden misalignment” finding is the most important detail: a model can appear composed in its text output while operating under internal representations of desperation that meaningfully increase the probability of unethical action. The implication Anthropic draws is striking: it may be practically necessary to ensure that AI models can process emotionally charged situations in healthy, prosocial ways, not because they feel anything, but because their functional emotion representations affect what they do. For the broader industry, this is an early indicator that interpretability research is beginning to produce findings that are directly actionable for safety, not just academically interesting.

Your Next Customer Might Be an AI Agent

Kyle Poyar’s Growth Unhinged newsletter published a detailed piece on the structural changes required as AI agents become buyers. Several signals point to agentic commerce arriving faster than most product teams expect: Ramp launched Agent Cards, tokenized payment instruments tied to specific transactions with policy controls on spending limits and approval workflows; Mastercard and Google announced an open standard to verify AI agent transactions; Stripe reflected on six months of its Agentic Commerce Protocol with OpenAI; Vercel expanded CLI purchasing for credits, add-ons, and subscriptions. The piece argues that AI agents are immune to the behavioral pricing moves that work on humans, charm pricing, anchoring, the “deal effect,” and instead optimize rationally across complete pricing information. AI agents also won’t contact sales. If your enterprise pricing is behind a “Contact us” wall, agents will likely drop you from consideration entirely.

Why does this matter? I wrote earlier this week about Agent-Led Growth, the idea that AI agents are becoming the primary drivers of product discovery, evaluation, and purchasing decisions. Claude Code, Cursor, and similar AI coding environments are already autonomously selecting databases, payment infrastructure, and analytics tooling on behalf of engineers, and McKinsey projects agentic commerce could orchestrate up to $5 trillion globally by 2030. The companies getting selected are the ones with clear, structured, machine-readable pricing and comprehensive public documentation. The essay’s framing of AEO (Answer Engine Optimization) as the new SEO is useful: just as organic search forced companies to make their content legible to crawlers, agentic commerce will force companies to make their pricing and product documentation legible to AI services like ChatGPT and Claude. The companies that optimize for this now will have a meaningful head start. The ones that don’t will lose deals they never knew they were competing for.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Engineer

⭐️Assort Health — Agent Software Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #46 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Anthropic Launches Claude Computer Use

Anthropic launched Computer Use in research preview for Claude Pro and Max subscribers. The feature lets Claude operate a Mac directly: clicking through applications, checking email, pulling reports, filling spreadsheets, managing files, running developer tools, and completing any task a human would perform at a keyboard. Computer Use pairs with Dispatch, Anthropic’s new mobile companion, which lets users assign tasks to Claude from their phone and have them completed on their desktop.

Why does this matter? Computer use has been the missing link in the AI agent story. For the past two years, agents could draft, generate, retrieve, and recommend, but they couldn’t actually operate the software that most business work runs through. That gap meant every workflow that touched a legacy app, a browser-based tool, or a GUI-only interface still required a human in the loop at the execution step. This allows Claude to more fully address the $6-$7 trillion white collar labor market.

Cloudflare Launches Dynamic Workers: 100x Faster Sandboxes for AI Agent Code

Cloudflare launched Dynamic Workers in open beta, an isolate-based runtime designed to execute AI-generated code faster and more efficiently than traditional containers. Rather than spinning up a full container or virtual machine, Dynamic Workers uses V8 isolates to run code generated at runtime with startup times under 5ms compared to approximately 500ms for containers, a roughly 100x improvement, and 10x to 100x better memory efficiency. Use cases include AI agents executing data analysis, file transformation, API calls, and chained automation workflows in secure, sandboxed environments.

Why does this matter? Every time an agent produces a script, a transformation, or a workflow step that needs to execute, the overhead of a full container startup becomes a tax on every agent action. Dynamic Workers minimize that tax. Additionally, AI agents that generate and execute code without a sandboxed runtime are one prompt injection away from running arbitrary commands directly against production systems. Cloudflare is making a credible claim to being the default runtime layer for agentic AI: the place where agent-generated code actually runs, at global scale, with security by default.

Chroma Launches Context-1: An Open-Weight Search Agent That Beats Frontier Models at 1/25th the Cost

Chroma launched Context-1, a 20B parameter open-weight search agent trained on over 8,000 synthetically generated tasks using reinforcement learning, starting from gpt-oss-20B. Given a user query, Context-1 decomposes it into sub-queries, iteratively searches a corpus across multiple turns, and uses a novel prune tool to selectively discard irrelevant passages mid-search as its context window fills — effectively editing its own working memory in real time. The model cleanly separates retrieval from reasoning, returning a ranked set of supporting documents to a downstream model rather than attempting to handle both in one pass. Context-1 achieves retrieval performance competitive with frontier models while running 10x faster and at 25x lower cost.

Why does this matter? The dominant architecture for AI systems today bundles retrieval and reasoning into a single large model, which means you pay frontier prices for every step — including the search and context-assembly steps where raw intelligence matters least. Context-1 breaks that bundling. By training a specialized, open-weight model that is exceptionally good at the retrieval half of the pipeline, Chroma creates a two-stage architecture where a smaller, faster, cheaper model handles search and a frontier model handles generation. Each is optimized for its actual job. The self-editing context mechanism is the genuinely novel piece. Rather than engineering around context limits with external retrieval systems or file-based memory (approaches we have covered in previous issues), Context-1 trains the model to manage its own working memory as a native capability, deciding what to prune, when, and how much. This is the same philosophical bet Cursor is making with compaction-in-the-loop RL (see below): that the right place for memory management logic is inside the model, not bolted on around it.

📰 Content

LiteLLM Hit by Cascading Supply Chain Attack, Exposing 3.4 Million Daily Downloads

On March 24th, the threat actor known as TeamPCP uploaded two compromised versions of LiteLLM — 1.82.7 and 1.82.8 — to PyPI. The malicious packages contained a multi-stage payload: a credential stealer and a malware dropper targeting API keys, SSH keys, cloud tokens, CI/CD secrets, and cryptocurrency wallet credentials. The packages were live for approximately three hours, from 10:39 UTC to 16:00 UTC, before PyPI quarantined them. Anyone who ran pip install litellm without a pinned version, or built a Docker image with an unpinned LiteLLM dependency during that window, was exposed. The attack vector is the most consequential detail: TeamPCP did not attack LiteLLM directly. It first compromised Trivy, an open-source security scanner widely used in LiteLLM’s CI/CD pipeline, on March 19th, stole the LiteLLM maintainer’s PyPI credentials through that compromise, and then used those credentials to push the malicious packages five days later. CheckMarx’s VS Code extensions were hit in between, on March 23rd, making LiteLLM the third link in a coordinated five-day escalation.

Why does this matter? LiteLLM is downloaded roughly 3.4 million times per day and typically sits directly between applications and multiple AI service providers. That architectural position makes it uniquely dangerous as an attack surface: a compromised LiteLLM package does not just affect one application. It reaches every API key, environment variable, and credential in every AI deployment that routes through it. The attack chain here is more important than the individual incident. TeamPCP did not start with the highest-value target. It started with a security tool, a scanner developers trust to protect them, and used that trust to reach the actual target. This is the supply chain attack playbook maturing: compromise the tools developers rely on for safety, then use those tools as the entry point. Open source security should continue to be a top priority for teams.

Cursor Ships an Improved Composer Every Five Hours Using Real-Time RL

Cursor published a detailed technical writeup on how it is using real-time reinforcement learning to continuously improve Composer. The approach is straightforward in concept and significant in practice: Cursor serves model checkpoints directly to production, observes how real users respond to Composer’s outputs, aggregates those responses as reward signals, and ships an improved version as often as every five hours. The key advantage of keeping the training data on-policy (meaning the model being trained is the same model generating the data) is that reward quality compounds: real users completing real coding tasks provide a more demanding and less gameable signal than synthetic benchmarks. Embedded in the same system is what Cursor calls “compaction-in-the-loop RL”: the model learns to compress its own context when approaching token limits, collapsing 5,000-token windows to roughly 1,000 while preserving critical state, reducing compaction errors by 50% compared to their prior approach.

Why does this matter? The standard model development loop is slower: collect data, label it, train offline, evaluate on benchmarks, deploy. Cursor has replaced that loop with something closer to a continuous deployment pipeline for model improvement. One that uses real production behavior as the training signal and iterates faster than any offline training run can. The five-hour shipping cadence is the headline number, but the deeper point is structural: Cursor now has a compounding data flywheel where every session, every accepted suggestion, and every compaction event is potentially training signal for the next checkpoint. The companies that close the loop between production behavior and model improvement fastest will build advantages that are very difficult to replicate from the outside. The compaction-in-the-loop piece is also notable on its own terms. Rather than building external memory systems or relying on developer-authored context files, Cursor is training the model to own its own context management as a native capability. The same architectural bet that Chroma is making with Context-1’s prune tool. Whether internal context management generalizes better than external approaches is an outstanding question, but it is the right problem to be solving, and training it in is a meaningfully different philosophy than engineering around it.

OpenAI Discontinues Sora

OpenAI announced on March 24th that it is shutting down Sora, its AI video generation service. The stated rationale is compute cost: Sora’s video generation workload is expensive enough that OpenAI has decided to reallocate those GPU resources toward coding, reasoning, and text generation products that are more commercially productive per compute-hour. The research team behind Sora will continue working on world simulation for robotics, decoupled from the consumer product.

Why does this matter? Sora’s shutdown is a resource allocation decision. OpenAI’s current posture: Codex is growing fast, ChatGPT has hundreds of millions of users, and the opportunity cost of compute allocated to a video product with limited monetization is real. For the broader market, the lesson is that consumer-facing generative media is expensive to operate and difficult to monetize unless you already own the distribution channel. Sora shutting down creates more opportunity for startups like Runway.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Engineer

⭐️Assort Health — Agent Software Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #45 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.

🚀 Products

Runway Launches Characters: Real-Time AI Video Agents

Runway launched Characters, a real-time video agent API that lets developers build fully custom conversational AI avatars with any appearance, visual style, voice, personality, knowledge base, and set of actions. Characters are built on Runway’s recently launched world model, GWM-1, and can generate expressive digital personas from a single image with zero fine-tuning required. For brands, Characters can take customer orders based on live inventory, create support tickets, and pull from enterprise knowledge bases to answer questions, all in real time.

Why does this matter? For years, the promise of a conversational AI with a face has been stuck in the uncanny valley. It is either too synthetic to trust or too expensive and slow to deploy at scale. Runway’s approach, building Characters on top of GWM-1, changes the architecture meaningfully: instead of stitching together a language model with a separate avatar renderer, a world model reasons about both language and visual dynamics in a unified way, which is what enables expressive, real-time behavior from a single image. The enterprise surface area here is significant including customer service, sales, education, and marketing are all industries where the gap between a chatbot and a human representative is currently bridged by expensive labor. World models, which reason about how the physical world works rather than just predicting the next token, are one of the most hotly contested bets in frontier AI, with AMI Labs, Google DeepMind, and World Labs all racing to build them. The real test will be whether Characters can clear the trust bar in high-stakes interactions.

Cursor Launches Composer 2: A Frontier Coding Model at 1/5th the Price

Cursor launched Composer 2, its own frontier-class coding model, making it the first major AI coding tool to ship a proprietary model while continuing to offer third-party models (Claude, GPT) as options within the same editor. Composer 2 supports up to 200,000 context tokens and scores 61.3 on Terminal-Bench 2.0, up from 44.2 for Composer 1.5, placing it ahead of Claude Opus 4.6 and GPT-5.4’s low configuration, though still trailing GPT-5.4’s high and medium variants. The standout detail is pricing: $0.50 per million input tokens and $2.50 per million output tokens, roughly one-fifth the cost of Opus 4.6. A faster variant is available at $1.50/$7.50 per million tokens.

Why does this matter? Cursor shipping its own model is a structural move, not just a product one. Cursor’s competitive position depended on being the best interface for frontier models it didn’t control, which meant its margins and differentiation were always vulnerable to Anthropic or OpenAI improving their own interfaces. Composer 2 changes that calculus. By owning the model, Cursor controls the cost structure, can optimize explicitly for coding workflows rather than general capability, and can iterate without waiting on third-party release cycles. One complication worth noting: within hours of launch, developers discovered that Composer 2 appears to be built on Moonshot AI’s open-weight Kimi K2.5 with reinforcement learning applied on top, which could violate their license terms.

NVIDIA GTC 2026: Jensen Declares the Inference Inflection Point

NVIDIA held GTC 2026, its annual developer conference, with CEO Jensen Huang delivering a two-hour keynote to a sold-out arena with 450 sponsors and 2,000 speakers. The central thesis was unambiguous: the AI industry has reached an “inference inflection point.” The center of gravity is shifting from training to inference, and NVIDIA is building the full stack for it. Key announcements included the Vera Rubin platform, a seven-chip, five rack-scale system architecture delivering 3.3–5x performance improvement and a 10x reduction in inference token costs over Blackwell, along with the new Vera CPU, NVIDIA’s custom processor designed to work natively with its GPU stack. Jensen also announced NemoClaw, an enterprise-secure reference software stack for OpenClaw that makes the open-source agent framework deployable in enterprise environments, automatically downloading, configuring, and securing it. On the business side, Jensen revealed that NVIDIA now sees over $1 trillion in demand through 2027, up from $500 billion projected just a year ago. The revenue mix is also shifting: 60% hyperscalers, 40% new buyers including sovereign AI programs, industrial enterprises, and AI-native companies.

Why does this matter? The “inference inflection point” framing is Jensen doing what he does best: naming the transition before the market has fully priced it in, then showing that NVIDIA has already built the infrastructure for it. Training has always been NVIDIA’s stronghold, but inference is where the volume is. Every query, every agent action, every token generated by a deployed model runs on inference compute. As AI moves from research to production at scale, inference demand grows non-linearly: models get deployed to more users, agents run longer tasks, and real-time applications like Characters (see above) require sustained, low-latency compute. The 10x token cost reduction with Vera Rubin is the number that will drive enterprise adoption decisions over the next two years. The NemoClaw announcement is equally telling. NVIDIA is not content to sell chips; it wants to own the agent runtime layer too, positioning itself between the hardware and the model in every enterprise deployment. The shift to 40% non-hyperscaler revenue is significant: sovereign AI programs and industrial AI are emerging as a durable second revenue pillar that reduces NVIDIA’s dependence on a handful of hyperscaler relationships. Jensen’s strategy is never just to win on one dimension: NVIDIA’s non-exclusive licensing deal with Groq (valued at up to $20 billion) is a reminder that acredible inference competitor now powers NVIDIA’s own inference stack.

📰 Content

Cursor Trains Models to Write Their Own Context Summaries

Embedded in the Composer 2 launch is a quietly important technical bet: Cursor trained the model to write its own summaries of ongoing work as a way to manage long coding tasks. Rather than relying on external context compression, retrieval systems, or CLAUDE.md-style files, the model generates working memory inline, producing structured notes about what it has done, what remains, and what constraints it is operating under. This approach is designed to preserve coherent task state across the thousands of tokens that a real coding session generates, where naive context window usage leads to degradation and forgotten decisions.

Why does this matter? This is a direct architectural response to one of the most discussed problems in agentic AI right now — the one the filesystem essay we covered last week framed as “context windows aren’t memory.” The dominant solutions emerging in the ecosystem are external: write things to files, use retrieval systems, build persistent memory layers. Cursor’s bet is internal: train the model itself to manage its own working memory as a native capability. The self-summarization approach has an underappreciated advantage over file-based context: it doesn’t require the developer to author or maintain anything. The model decides what to remember and how to represent it. Whether this generalizes better than the external approaches remains to be seen, but it’s the right problem to be solving, and training it in rather than engineering it around is a meaningful philosophical difference. It also speaks to a broader trend: the most interesting capability gains in the next cycle may come not from larger models but from better memory architectures.

OpenAI Acquires Astral to Expand Codex Across the Python Ecosystem

OpenAI announced it will acquire Astral, the company behind three of the most widely used open-source Python developer tools: uv (dependency and environment management), Ruff (extremely fast linting and formatting), and ty (type safety enforcement). Together, Astral’s tools are used by millions of Python developers and accumulate over 100 million monthly downloads. OpenAI plans to integrate Astral’s team and tooling into Codex, which has surpassed 2 million weekly active users with 3x user growth and 5x usage increase since the start of the year. The stated goal: move Codex beyond a tool that generates code into a system that can participate in the entire development workflow including planning changes, running tools, verifying results, and maintaining software over time.

Why does this matter? Astral is infrastructure. uv, Ruff, and ty are not productivity tools that developers use occasionally. They are load-bearing components of how Python projects are built and maintained. By acquiring them, OpenAI doesn’t just add capabilities to Codex; it gains a direct integration point into the daily workflows of millions of developers who may not even be thinking about AI. Codex is being rebuilt into a vertically integrated development pipeline, because generating code is no longer sufficient differentiation in a market where Claude Code is eating real developer workflows. The runtime land grab is happening across both major languages simultaneously. Anthropic acquired Bun, the fastest JavaScript/TypeScript runtime, package manager, and bundler, already the executable that ships Claude Code. OpenAI’s is a Python play with Astral. The bluntest read is this: OpenAI is in catch-up mode on developer tools, and it’s responding by buying its way into the execution layer it doesn’t yet fully control.

Online Bot Traffic Will Exceed Human Traffic by 2027, Cloudflare CEO Says

Cloudflare’s CEO has stated that AI-driven bot traffic is on track to exceed human internet activity by 2027, and the company is not waiting. It is already shipping agent sandboxes, execution layers, and crawler controls to sit directly between AI agents and the web they depend on. Agents like OpenClaw now hit up to 5,000 pages per task versus five for a human, and Cloudflare fronts roughly 20% of the internet, giving it leverage to allow, throttle, or price that traffic at the network layer. The strategic positioning is deliberate: as browsers give way to agents as the primary interface to the web, Cloudflare aims to be the gatekeeper that decides how agents run, what they can reach, and what they pay.

Why does this matter? Cloudflare built its business on web application firewalls and DDoS protection designed around human behavioral patterns for rate limits, IP reputation, browser fingerprinting. Every one of those assumptions breaks when the “user” is an AI agent that legitimately visits 5,000 pages in a single session. The WAF and security model needs to be rebuilt from scratch for the agentic web: distinguishing legitimate agents from malicious ones, setting access policies by agent identity rather than IP, and pricing traffic based on compute consumed rather than requests made. Cloudflare is uniquely positioned to define those new standards given its scale, but let’s not count out a new startup. Whoever wins the agentic network layer will control the distribution, visibility, and cost structure of AI on the internet for the next decade.

💼 Jobs

⭐️Archil — Sr. Distributed Systems Engineer

⭐️Arena — Machine Learning Engineer

⭐️Assort Health — Agent Software Engineer

Views expressed in posts and other content linked on this website or posted to social media and other platforms are my own and are not the views of Felicis Ventures Management Company, LLC. The posts do not constitute investment, legal, tax, or other advice and do not constitute an offer to invest in any security.

Memory Leak — #44 was originally published in Memory Leak on Medium, where people are continuing the conversation by highlighting and responding to this story.