Jalapeño is not just the first chip designed by OpenAI. It is a strong signal that artificial intelligence is entering the design cycle of its own infrastructure, potentially giving OpenAI an advantage that could become extremely difficult for others to close.
When OpenAI introduced Jalapeño last June, the most immediate interpretation was fairly predictable: OpenAI also wants to reduce its dependence on NVIDIA and build an accelerator designed specifically for its own models.
That is certainly part of the story, but I don’t think it is the most interesting part.
Google has been developing its TPU platform for years, Amazon has Trainium and Inferentia, Microsoft has Maia, and almost every hyperscaler is trying to build its own alternative, at least partially, to NVIDIA GPUs. Considering how much OpenAI spends on compute capacity, moving beyond the NVIDIA platform and eventually developing a proprietary chip was almost inevitable.
Jalapeño, however, comes from a very different starting point.
OpenAI is not a semiconductor company that decided to enter artificial intelligence. It started by building models, then products such as ChatGPT and Codex, inference systems, meaning the systems through which an already trained AI model processes new data to generate a response, classification or prediction, APIs, and infrastructure capable of serving those models at a scale that is difficult to replicate. Only after accumulating all of this experience did it begin moving into hardware, asking what kind of processor it would build if its primary purpose were to run today’s LLMs and those OpenAI expects to develop over the next few years.
More importantly, during this process OpenAI used its own AI models to help design the chip. This is where the story changes and becomes much more interesting. We no longer have only software designed to make better use of a processor; we now have software beginning to help engineers design the processor on which the next generation of that same software will run.
Nine months to reach silicon
Jalapeño is OpenAI’s first Intelligence Processor, developed with Broadcom and with Celestica contributing to board, rack and system-level integration. OpenAI defined the architecture around its own workloads, while Broadcom brought decades of expertise in areas ranging from silicon implementation to high-performance networking.
What is surprising is the speed.
According to OpenAI and Broadcom, it took approximately nine months to move from the design phase to the final chip design, a development cycle the two companies consider potentially one of the fastest ever achieved for a high-performance ASIC of this complexity. This does not mean that all the work was finished in nine months, but it does mean that one of the most expensive and complex stages of the entire process had been completed.
OpenAI explicitly attributes part of that speed to the use of its own models. AI was used to explore different implementations, shorten the cycles between design, measurement and verification, and optimize some of the arithmetic circuits, allowing engineers to fit more compute into the design while remaining within the project’s schedule.
This point needs to be interpreted correctly. Jalapeño is not a chip that an AI autonomously designed while the engineers stood around watching. Behind it are human teams, and it almost feels strange that we now need to specify this, from OpenAI, Broadcom and Celestica, together with extremely specialized expertise in semiconductor design, packaging, memory, networking and manufacturing.
But it would be equally wrong to dismiss the role of AI as little more than assistance in writing a few lines of code.
OpenAI says that AI participated directly in the design cycle and continues to be used even after the silicon was produced, helping program and optimize the chip. Using Codex with GPT-Astra, the team was able to bring three open-weight models, GPT-OSS, DeepSeek R1 and Kimi K2.5, which had not been part of the original production plan, to high performance on Jalapeño within two months.
AI is not simply using the new hardware. It is helping build it and, once it exists, learning how to program and optimize it.
Why OpenAI can design a different kind of chip
NVIDIA and AMD have to solve a much broader problem.
An NVIDIA or AMD GPU has to be flexible enough to serve thousands of customers, different model architectures, training, fine-tuning, inference, scientific simulation, robotics and applications that probably did not even exist when the chip design process began.
That generality is also one of their greatest strengths. NVIDIA, in particular, does not simply sell GPUs. Over the years it has built an entire ecosystem that has become part of the fundamental infrastructure of modern AI.
This is precisely where OpenAI has a different advantage: it does not necessarily need to build the best processor for everyone. It needs to build an exceptionally efficient processor for the workloads it understands better than almost anyone else.
Every day, OpenAI can observe how ChatGPT, Codex, its APIs and its agents are actually being used. It can see where time is being spent, which operations become expensive when multiplied across millions of requests, how memory requirements compare with raw compute, how workloads change as contexts become longer, and how even a small amount of latency added to each step becomes significant when an agent needs to perform dozens or hundreds of steps before completing a task.
Those observations are useful not only for improving the software. They can become requirements for the next generation of hardware.
Jalapeño was designed from precisely this kind of perspective. During LLM inference, the initial phase tends to be highly compute-intensive. The subsequent generation of tokens depends much more heavily on memory bandwidth, while communication between chips and nodes can introduce significant delays when model state has to be moved continuously.
OpenAI therefore designed the system as a whole, attempting to reduce unnecessary data movement and keep as much model state local as possible, while allowing the system to adapt to the different phases of inference. It did not take an existing GPU and ask how best to run an LLM on it. It started by asking what the hardware should look like if the LLM itself were the starting point.
That difference could become particularly important with agents, because an agent does not make one request and stop. It reasons, uses tools, receives a result, updates its context and continues. A relatively small reduction in latency for a single step can therefore be multiplied across every action required to complete a task.
The first benchmarks are impressive, but they are still internal results
On August 25, OpenAI published the first Jalapeño benchmarks measured using InferenceX, testing not only GPT-OSS 120B but also DeepSeek R1 670B and the one-trillion-parameter Kimi K2.5.
According to the company’s results, Jalapeño delivered between 1.5 and 1.9 times more AI work per watt than the commercial systems used for comparison. For workloads particularly sensitive to performance, the claimed advantage rises to between 2.1 and 4.1 times.
These are certainly impressive results for a first generation, particularly because Jalapeño maintained an advantage with models that were not developed by OpenAI. But we should avoid jumping to conclusions: these benchmarks were published by OpenAI and will need to be verified over time through broader testing and independent comparisons.
So we cannot yet say that OpenAI has beaten NVIDIA. That is not the point.
What matters is that OpenAI has reached working silicon while the second generation is already at an advanced stage of development and the third is beginning to take shape.
It is the speed at which this cycle can repeat that I find much more interesting than the performance of the first chip.
Anthropic has the models, but it does not own the chip
The comparison with Anthropic is perhaps even more interesting because it starts from the same side of the development chain as OpenAI.
Anthropic was not born as a processor company. It was created to build frontier models, and Claude is now one of OpenAI’s most important competitors. The company therefore has a very deep understanding of its own workloads and could, at least theoretically, benefit from the same kind of integration between model and hardware.
The difference is that Anthropic does not currently have a proprietary accelerator equivalent to Jalapeño.
To obtain the compute capacity it needs, Anthropic is following a multi-provider strategy and investing enormous amounts in access to hardware built by other companies. In April 2026 it expanded its partnership with Google and Broadcom, and during the same month extended its relationship with Amazon with commitments exceeding $100 billion over ten years, without even considering its use of external data-center capacity such as Colossus.
This is not necessarily a bad strategy. In fact, it allows Anthropic to use different technologies without directly assuming the enormous industrial and financial risks involved in designing silicon. It can collaborate with other companies on hardware while continuing to use NVIDIA architectures whenever they make sense.
There is nevertheless a fundamental difference. Anthropic can explain to Google or Amazon how Claude uses their hardware and can work closely with them to optimize it, but ultimately the processor roadmap belongs to another company, one that must also satisfy other customers, other products and other priorities.
OpenAI, with Jalapeño, can instead begin with the roadmap of its own models and translate that directly into the roadmap of its own silicon.
If two years from now OpenAI believes that a particular model architecture, reasoning technique or new type of agent will require a completely different relationship between memory, compute and networking, it can begin designing that requirement into the chip before the model ever reaches users.
Anthropic can ask its hardware provider to do that. OpenAI can increasingly make it part of its own architecture.
NVIDIA and AMD are travelling in the opposite direction
NVIDIA and AMD are coming from the other side. They started with silicon and are progressively building more software and AI layers on top of it.
NVIDIA has become much more than a hardware infrastructure company and is developing model families such as Nemotron for agents and enterprise applications. AMD is doing something similar at the platform level, attempting to build an increasingly complete AI stack from data centers to local workstations.
The difference is the direction from which they are approaching the problem.
NVIDIA and AMD possess decades of expertise in hardware design and are moving upward toward models and AI software. OpenAI possesses experience with models and products and is moving downward toward silicon. Anthropic has the models but, at least for now, stops before proprietary hardware.
None of these strategies automatically guarantees victory, but OpenAI’s approach creates a particularly interesting combination because every layer of the system can potentially provide information directly to the next one.
The advantage is not Jalapeño. It is the cycle Jalapeño can set in motion
I am very cautious about using words such as “unbridgeable” when discussing technology, particularly when NVIDIA is on the other side.
NVIDIA has an extraordinary market position, enormous industrial capabilities and a stack built over decades. Jensen Huang and his team clearly understand that the future is no longer determined by the individual chip, but by the entire system of compute, memory, networking, storage and software. AMD, meanwhile, continues to invest heavily in building an increasingly credible alternative around open standards.
What could become extremely difficult to catch up with is therefore not the performance advantage of Jalapeño Gen 1. It is the feedback loop OpenAI is trying to create.
Today’s models help engineers design a better chip. That chip reduces the cost and latency of inference. Cheaper inference makes it possible to run more requests, longer reasoning processes and agents capable of taking more steps. Those workloads generate new operational data and expose bottlenecks that we may not even be able to see today. Those observations can then be used to design both the next models and Jalapeño Gen 2 and Gen 3, while using AI tools more capable than those that helped develop the first generation.
The cycle could therefore become:
better AI → faster hardware design → hardware better suited to AI → faster and cheaper inference → more capable agents → even better AI → a new generation of hardware.
It is this integration that could become the real moat. Not because NVIDIA cannot build better hardware, but because it has to build hardware for an entire market; and not because Anthropic cannot build better models, but because OpenAI can begin optimizing both ends of the stack at the same time.
When the model already knows the chip that does not exist yet
There is another, subtler consequence.
Traditionally, a new processor is designed and manufactured, and only afterwards do developers begin figuring out how to use it efficiently. Compilers, kernels and libraries have to be developed, followed by months or years of optimization before software truly exploits everything the hardware can do.
With Jalapeño, these processes are beginning to overlap. AI helps design the chip while, at the same time, the chip is designed so that AI can help program it. OpenAI has deliberately tried to create an architecture predictable and clear enough for models to reason about how computation should be distributed.
This means that when a new model architecture arrives, it may no longer be necessary to wait for a group of engineers to manually write every optimization. AI can contribute to generating, measuring and improving the implementations needed to use its own hardware.
Today, that means Codex helping to write kernels. Tomorrow, it could mean a model exploring thousands of variations of part of an architecture, identifying the most promising ones, helping verify them and then generating the software needed to exploit the resulting silicon.
At that point, the boundaries between model design, compiler design and chip design begin to become much less distinct.
The cost of intelligence becomes part of the model
There is also an economic reason why all of this matters.
Over the past few years, we have focused primarily on model capability. Every new generation is judged by whether it reasons better, writes better code or solves more difficult benchmarks.
With agents, as we are also beginning to see directly from experiences with systems such as OpenClaw and Hermes, the cost of obtaining a result becomes just as important. A chatbot may produce an answer through a single, relatively short inference. An agent can perform fifty, a hundred or a thousand steps, query tools, maintain enormous contexts and generate vastly more tokens before completing its task.
If every step costs too much or takes too long, some applications simply never become economically viable.
This is why doubling efficiency does not merely mean cutting one line of the data-center bill in half. It can mean that an agent that was previously too expensive suddenly becomes economically sustainable.
OpenAI has been fairly explicit about this: Jalapeño needs to increase the amount of useful work produced from the same quantity of hardware and energy. If it succeeds, the hardware advantage becomes a direct product advantage.
A faster Codex can make more attempts while we wait. An agent can investigate a problem more deeply without becoming economically absurd. ChatGPT can offer heavier reasoning modes to a much larger audience.
At that point, the chip is no longer merely a hidden component inside a data center. It becomes an indirect part of the model’s capabilities.
AI beginning to build its own future versions
For decades, humans have designed hardware and software while machines simply executed them. That relationship could now begin to change radically. Thinking about it, this is ultimately the most interesting part of Jalapeño.
AI systems will not simply use tools designed by others. They will increasingly contribute directly to the development of their own future versions by suggesting architectures, generating and verifying code, optimizing compilers and exploring new hardware configurations.
Jalapeño represents one of the first steps in that direction.
Humans will continue to define objectives and constraints, but models will participate increasingly deeply in the design of their own hardware and the software required to use it. The workloads produced by one generation will reveal the limitations of the system and help shape the next one.
The result could become a recursive development process: one model helps design a more efficient chip, that chip enables the development of more powerful models, and those models in turn become more capable of designing better hardware and software.
It will not yet be a completely autonomous system, but AI will be contributing directly to the construction of the infrastructure required for its own evolution.
When that process becomes fast enough, competition will no longer be simply between the best model and the most powerful processor. It will be between companies in which hardware, software and AI evolve separately and companies in which every generation contributes to the design of the next.
This may be where we begin to see one of the first concrete signals of AGI, not because a system suddenly becomes capable of performing every human task, but because it has begun to participate in its own evolution.
Jalapeño may therefore be remembered not simply because OpenAI built a chip, but because AI began building the hardware and software on which its future versions would run.