Who Owns the Stack When the Stack Starts to Think?
OpenAI, Astral, and Perplexity in a world where infrastructure becomes the product
1. The quiet redefinition of “focus”
When OpenAI says it is “focusing on the core stack,” the phrase is easy to mistake for modesty. It sounds like a retreat from spectacle: no ad networks, no viral video apps, no glossy consumer novelties. Yet the Astral acquisition shows almost the opposite. Astral’s tools — uv for dependency management, Ruff for linting and formatting, ty for type checking — sit in the unglamorous heart of Python development, where most people never look and everything depends on nothing breaking. To choose this terrain is not to lower one’s sights; it is to move the battlefield to the place where habits harden and change is slow.
For years, AI was presented as something you visited: a website, an app, a model demo. In that framing, the underlying build system, the package manager, the type checker were neutral scenery. The purchase of Astral is a declaration that the scenery is now in play. OpenAI is not simply buying tools; it is buying the ability to shape the environment in which its coding assistant, Codex, will live. The official line is that Astral will help move from “AI that generates code” to systems that can “participate in the entire development workflow.” Translated, this means: the model will stop acting like a guest in the development process and start acting like a co-owner.
2. Tools that become organs
Astral’s founder describes the deal as a continuation of the same mission: making programming more productive, with open source at the center. OpenAI’s statements promise ongoing support for uv, Ruff, and ty as open projects while folding the team into Codex. On the surface, nothing is being taken away. The commands will remain the same. The repositories will stay online. Bugs will be fixed, probably faster.
The real change is subtler. A tool used to answer to an ecosystem: many users, many use cases, all tugging at its roadmap from different directions. Inside a larger platform, that diffuse pressure condenses into a single, persistent question: “What makes Codex more capable, more trustworthy, easier to sell?” If a trade-off appears between a niche community desire and a feature that makes long-lived AI agents easier to embed in enterprise workflows, the resolution is not difficult to predict. The linter and the package manager acquire a new center of gravity. They are still tools, but now they are organs of a larger body.
From the outside, this can look like generosity: more investment in developer experience, more polish, more integration. From the inside, it is a way of tightening the feedback loop between what the model can do and what the environment allows. A coding agent that understands the package manager’s rules, knows the linter’s expectations, and can trust the type checker’s guarantees is far easier to turn into something that feels like a “software engineer.” Owning Astral is a way of making that trust native rather than negotiated.
3. The race to own the floor
OpenAI’s move does not happen in isolation. Anthropic’s acquisition of Bun pulled the JavaScript runtime, bundler, test runner, and package manager into the orbit of Claude. Modular’s work on a new language and engine offers another path: rebuild the lower layers so they are optimized from the start for AI-heavy workloads. Each of these gestures is different in technology and culture, but they share a single intuition: the neutral “floor” everyone once built on is worth too much to leave unclaimed.
The Register notes the symmetry plainly: OpenAI buying Astral on the Python side, Anthropic buying Bun on the JavaScript side, both in the context of intensifying competition. Commenters point out the broader stakes: this is an attempt to own, and then lease, the “means of production” in software, not just the finished products. Once the runtime, the package graph, and the linting pipeline belong to an AI platform, choosing another model is no longer a matter of swapping one API key for another. It becomes a matter of swimming against the current of a development experience that has been tuned, end to end, for one provider’s agent.news.
In such a landscape, the old distinction between “infrastructure company” and “application company” begins to blur. The infrastructure that matters most is no longer the generic ability to run code or store data. It is the ability to host a non-human participant in the workflow — an agent that can read, write, refactor, and deploy. Whoever controls the tools that define what counts as “valid” code, and how that code flows through a system, is well placed to decide how that participant behaves.
4. Perplexity in the middle layer
Perplexity’s “Computer” arrives into this same environment, but from a different direction. Rather than owning a language, a runtime, or a package manager, it orchestrates 19 models from other providers — OpenAI, Google, Anthropic, and others — and arranges them into something that feels like a digital colleague. It decomposes tasks, spawns sub-agents, remembers context across time, and connects to tools like email, spreadsheets, and CRMs. For someone doing research, analysis, or content-heavy work, this is a palpable shift: not a chat window, but a process that continues when you close the tab.
The problem Nate B. Jones and others point to is not in what Computer can do, but in where it stands. It occupies the “middleware” layer between model builders and end users. It depends on APIs controlled by companies that are now building their own long-running agents and orchestration systems. VentureBeat, for example, describes Perplexity as an “abstraction layer for AI” and immediately notes the obvious risk: the model makers can restrict access, undercut on price, or duplicate features. Geeky Gadgets, summarizing Nate’s analysis, phrases it almost as a paradox: the more impressive Computer becomes, the more it highlights the vulnerability of living entirely at the mercy of upstream providers.
In that sense, Perplexity and Astral are inversions of one another. Astral began as independent infrastructure and is being pulled downwards into a platform’s core. Perplexity begins as a visible, user-facing product and finds that the platform is expanding upward, towards it. Both stories describe the same gravitational field from different vantage points.news.
5. The economics of borrowed power
Most of the tools in this story — Ruff, uv, Bun, orchestration layers, agents — did not begin life as high-margin businesses. They were, for a long time, maintained by small teams with a mix of community goodwill, sponsorship, and, eventually, venture capital on the promise that “something bigger” would emerge. That bigger thing has turned out to be acquisition by companies whose own survival depends on turning AI from a curiosity into an unavoidable part of work.
Inside those companies, the value of a tool or an orchestration layer is measured less in direct revenue and more in leverage. Astral is worth acquiring if it makes Codex more attractive to enterprises, keeps developers from defecting, or helps close the gap between marketing slides and the messy reality of large codebases. Perplexity Computer is worth building if it convinces a critical mass of professionals to route their workflows through a system that Perplexity controls, even though the underlying models belong to others. In both cases, the tool is a bet on being close enough to the flow of work that it becomes difficult to dislodge.
This arrangement is stable only as long as the larger platforms consider the arrangement mutually beneficial. Astral’s investors can trade their stakes for equity in a future OpenAI listing; OpenAI can claim deeper ties to developers. Perplexity can argue that it drives additional usage to its model suppliers and helps them showcase their capabilities; the suppliers can decide, at any moment, that they prefer to own that experience themselves. The phrase “platform risk” is a polite way of naming this asymmetry.
6. Focus, from another angle
From a distance, OpenAI’s acquisition spree — devices, cybersecurity, developer tools, healthcare — can look like drift. It is easy to line up the logos and conclude that the company is chasing every adjacency. Yet read alongside the Astral deal and Perplexity’s position, a different interpretation presents itself. Each move, however disparate, stakes out a point where AI touches something non-trivial: code, infrastructure, safety, diagnosis, day-long workflows. The intention is not to dominate every application category in the conventional sense, but to interpose the model — and the tools the model prefers — wherever high-leverage work is decided and executed.
In that light, “focus on the core stack” is less a technical statement than a territorial one. It says: the center of our strategy is not the novelty of what the model can say, but the density of the places where it is allowed to act. Astral’s tools, Bun’s runtime, Modular’s engine, Perplexity’s orchestrator — all of these are, in different ways, attempts to shape those places. Some are being pulled inward into the gravity wells of the largest platforms. Others orbit in the middle distance, powerful but exposed.
The question that remains, for anyone building in this environment, is not only “what can we make the models do?” but “on whose floor are we standing while we do it?” The answer, increasingly, is less a matter of choice than of the slow, accumulating decisions that define what feels like the path of least resistance.