OpenAI just announced their AI chip,

Jalapeno, and I don't think anyone was

quite ready for this. Here's the big

headline that you need to know. This

chip beats Nvidia on the metrics that

matter when we're talking about using

and serving AI. So, this is their first

generation chip. It's supposed to be

bad. It's not supposed to be competitive

with all the other chips on the market.

That's not how things work. Instead,

this is a first generation chip. This is

the first chip that OpenAI has produced

and it beats Nvidia. It beats Google's

TPUs and it's not only for OpenAI's

models. This is tested across many

different open- source models. This is a

general chip. This is an industryleading

chip. How did OpenAI come out with this

killer industry destroying chip on their

first attempt? If you can't guess, then

you haven't been paying attention. This

hopefully will not come as a surprise

for anyone. They're saying right here,

they say it. We used AI to design the

chip and design the chip so AI could

program it. AI played a direct role in

Jalapenño's development, enabling the

team to move from initial design to tape

out in 9 months. By the way, this isn't

just OpenAI saying whatever they feel

like saying. Semi analysis actually went

there and tested this chip. We'll take a

look at the report in a bit. Some of the

pieces in there are kind of wild, but

really fast. Couple of things that are

important to understand. First and

foremost, this isn't like a GPU that can

be good at many different things. This

chip that they're building, the

Jalapeno, it's an ASIC application

specific integrated circuit. So, it's

basically it just does one thing. It

woke up one day and asked, "What is my

purpose?" And they told it to you pass.

But instead of passing butter, all it

does is it works with large language

models to do the inference. So the

outputs of your favorite chatbot, it's

designed to just do that as fast and as

efficient as possible. And the metric

that they're going by is performance per

watt. So basically, how much useful work

does a chip get done for every watt of

electricity that we give it. So really

what we're measuring is how efficiently

are we converting energy into AI output.

And energy is the big bottleneck right

now. That's the thing that's the hardest

to get. So how well does the jalapeno

line up against all the other giants?

all the other competitors that have been

working and perfecting their chips for

years. Well, here's the semi analysis

blog post. Shout out to those guys and

gals. Those have just amazing coverage

of the space. Okay, so remember we're

looking at the performance per watt.

That's kind of like what we're trying to

maximize. That's the most important

metric. How well does the Jalapeno

compared to every other chip? Jalapeno

smokes every other chip. That's semi

analysis who had a chance to run their

own test on this chip. So this is not

hearsay. They're saying jalapeno beats

blackwell on that metric performance per

watt across almost all scenarios without

being tuned for any specific point in

the curve. You want to do it fast. It

does it fast and it smokes every other

chip. You want to have a high

throughput. You want to have a lot of

stuff going through it. It still just

knocks everybody out. At low concurrency

scenarios, Jalapeno demonstrates

remarkable interactivity hitting over

700 tokens per second per user at

concurrency one on the DeepSseek R1

model. Now, keep this in mind, the Deep

Seek R1 model, because this chip did not

have the code needed to run this model

efficiently. Just put a pin in that

because you're going to want to see the

other side of the coin here in a second.

Now, I'll leave a link to semi analysis.

I encourage everybody to check it out

because there's tons of context here.

So, I'm not just cherry-picking the good

or the bad. There's a lot of stuff here

that we are not going to go into. They

have some caveats in terms of what tests

were were run. So they verified their

tests that were run in person in the

lab. They did not run the full suite,

nor have they seen their preferred suite

for comparing chip performance. So

there's still more tests to be done. But

this is where the other shoe drops. This

is kind of the other side of the coin.

And this is one of the more wildest

little nuggets of wisdom or things that

Simeon House has found at OpenAI. So

really fast, let's say you have this AI

chip. So this is our AI chip and here we

have our AI model. Does the AI model

just kind of go and run on the chip? No.

The chip can't do anything without

something telling it what exactly to do.

And that thing personified in this case

by the kernel. Kernel is basically just

code. It's it's written code.

Specifically, it's a small hyper

optimized piece of code that tells that

chip exactly how to do math. how to do

specific math to run this AI model like

matrix multiplication or various

attention mechanisms and good kernels

are notoriously hard to write. It's a

specialist work. There's a lot of

optimizations. So even if you have an A+

like a really good AI model, you have an

A+ chip. You have the best hardware. You

have like a D or an F level kernel C

minus whatever this could easily you

know cut the performance in half. So

when it was time to run the deepseek

probably the R1 model on this Jalapeno

chip, OpenAI had no internal

implementations of MLA kernels. MLA is

the multi- head latent attention. If

you're not familiar with it, it doesn't

really matter. It just DeepS had this

funky way of doing things that most

other labs they they just don't do it

that way. So they just have an unusual

architecture. Most other labs don't use

that. OpenAI models don't use that. So

open never had to have this code this

this kernel for MLA. So they're trying

to run a test. They're trying to use

this DeepSeek model. So this is

Deepseek. This is Jalapeno. And their

kernel just doesn't have the correct

code to make this run as good as it

possibly can on this. We'll come back

and dig a little bit deeper because this

is I think incredibly important to

understand because what happened in that

moment is codeex basically wrote

functional and efficient kernel very

very quickly to be able to run this

unusual sort of architecture on this

chip. Now why is that such a big big

deal? Because right now, one of the most

well-known, most used chips for AI is of

course the GPU that's by Nvidia. And

Nvidia has CUDA. CUDA is this

programming platform that has tons of

stuff, libraries, tools, etc., etc.,

that allows people to write good kernel

to run or train their AI models on the

GPU, the AI chips that Nvidia produces.

It's been around since like 2007. So

it's like two decades worth of progress

and additions and improvements plus very

simply a lot of engineer expertise,

right? So there's a lot of smart people

that have worked on this and spent time

on this. No one has anything close in

terms of an ecosystem. This is referred

to as the CUDA moat because if you're

writing on CUDA, then it's easy to hire

people that know the language. There's

tons of tools. There's tons of

knowledge. Like this is the path of

least resistance. It's super easy. But

if you're using CUDA, then you're using

Nvidia's chips. If somebody comes out

with a brand new chip that is awesome

and amazing and, you know, theoretically

better than the GPU in order to start

using it, you have to kind of rebuild

that kernel and everything everything,

you know, on whatever new platform or

you have to do it from scratch. So, I'll

write like the the skull and bones here,

right? This is difficult. Nobody wants

to do it. So, CUDA has 20 years of work

behind it. thousands, tens of thousands

of 100 thousand plus engineers, tools,

libraries, etc. The Jalapeno, you know,

has like however long it's been around,

like a month and probably like five

people that know how it works. But none

of that matters because OpenAI writes

Jalapeno kernels like assembly each

kernel. So that that code that tells the

chip how to run that particular AI

model. It gets handtuned code, some

running to 3,000 lines backed by

correctness checks and a custom

sanitizer. Early kernel work was human

loop but now it's getting fully

automated but now it's shifting to a

more scaled up internal version of

codeex one which openai plans to pitch

to enterprise customers. So, OpenAI is

not making this human friendly, right?

So, they're writing it like assembly.

They're writing at the most foundational

level. So, software development, you

might have these abstraction layers in

the top. It's something that's readable

and human friendly and assembly is at

the bottom rung of that ladder where

just you're writing everything raw by

hand. You control everything. The

machine does exactly what you say.

Nothing is handled for you. So Codeex

writes this kernel right at like the

metal right at that level. So Nvidia

spent 20 years developing their moat,

their CUDA moat. This is a big part of

why they're winning. AMD tried very

hard, but just their software kind of

kept disappointing people. It wasn't

quite as good. They failed to create the

same robust kind of ecosystem that

Nvidia has. Google has been spending a

lot of resources and time on this to try

to develop their ecosystem to try to

create something like CUDA. So for their

TPUs, they were trying to create

something similar that says TPU. And

next comes Open AI and they just go lol.

We're not going to do any of that. They

just didn't do any of that. And the

reason they can do that is because let's

say there are a few thousand people on

the planet that can write truly great

kernel code for these applications.

They're very scarce. There's not a lot

of them. You have to pay them a lot of

money and they mainly work with CUDA. If

AI can write competitive kernel for any

chip, then that scarcity. It just

disappears. This post goes into which

programming language they use for these

specific kernel tasks. They call it

Gluon. Gluon is OpenAI is a kernel

programming language. We're not going to

go into the details. Again, read the

post it. It's excellent. But the point

is, if I'm reading this right, and by

the way, keep in mind, I'm not an

expert, but if I'm reading this

correctly, then here's what happened.

For the last 20 years, the conventional

wisdom was basically that you needed to

build a very developer friendly, human

friendly ecosystem like CUDA. It needed

to be very easy, very friendly, and as

big as as possible, massive, so that

thousands and thousands of humans can

program it and and and use it. OpenAI

kind of flipped the script. They're

saying actually what probably you need

is a very small, sharp, tedious, very

very manual language plus an AI model

that's smart and more than happy to code

in that language. So, Gluon is that

language. Codeex is that AI model and

this linear layout, that's a type of

layout algebra that OpenAI invented. As

a semi- analysis puts it here, in a

weird twist of fate, OpenAI models like

GBT 5.6 ICS soul which currently run on

the Nvidia GPUs have been used to design

a chip that poses a real threat to the

CUDA moat. Nvidia's own GPUs are helping

usher in their potential successor in

real time. This is the RSI thing that

we've been talking about the recursive

self-improvement. It's like a flywheel.

It's slow at first, but then when it

gets moving, it it really gets going. We

train up this model. Then this model is

able to optimize the chips, design new

chips, write all the code for those

chips. It can do it in a way that humans

can't compete with. Keep in mind, it

optimized the hardware and also writes

the software. It handles both sides. Not

entirely. There's, like they said,

humans in the loop. There's a lot of

very smart engineers working on it. So,

it's not like any of this is 100% fully

automated yet, as far as we know. By the

way, the rumors that everyone's hearing

are just insane. Open recently finished

the next pre-train code named Bell, the

successor to Doug, which is expected to

be the base for Astra and GPT6. It's a

giant pre-train with over 10 trillion

total parameters and it could

potentially be the base for an AGI

threshold model. Very quick note going

back to the semi analysis post. Notice

they say here that that flexibility

again you can read about what they're

talking about but that flexibility buys

valuable optionality for future 10 to 20

trillion parameter models. So you you

get that the chip that they build can

run those models. The the big chunker of

a model that chip runs it or a 2 to four

million token context windows. Rumors on

the rate of progress inside Anthropic

and OpenAI are truly bonkers. I think

we'll see a jump the size of one from 03

to Fable. We'll see that sort of jump

again in the next 8 months. So, this is

a chubby on X Kimmanismus. How do you

say the guy's name? I finally know what

he looks like. That's him, Kim

Eisenberg. And he's like the the the AI

news on Twitter/X. I don't know when and

if he sleeps because I feel like he's

just on top of like everything. But

here's what he posted about three hours

ago and it really struck a bell with me

because I'm seeing and hearing more or

less exactly the same thing. He's

saying, quote, "I'm currently hearing

countless rumors about just how

significant the leaps in capabilities

will be with the models that have yet to

be released. The gains are said to be

substantial across the board at both

OpenAI and Anthropic. There are also

persistent rumors that context and

memory have been solved along with

reports of self-improving models capable

of continual learning. Of course, these

are all just rumors, but given how

optimistic and bullish these companies

have been and how cautiously firms such

as OpenAI have recently acted, delaying

releases in response to tectonic shifts

and capabilities, there may be more to

this than mere speculation. So, as Sam

Alman puts it here, we made a chip and

it is fast. So, this program was first

announced October 2025. Opening eyes

saying the 9month development cycle

which is extremely fast for something of

this nature formally unveiled as

Jalapeno June 2026. And now we have our

first benchmarks and third-p partyy

reports. They're kind of confirming it

as semian also says you know we still

have to run their full suite of tests

but at this point I mean I mean this is

real. So very small volumes of these

chips will be used in OpenAI data

centers this year. They're going to

start, you know, ramping up using them

this year and then a ramp up in 2027. So

notice how Amazon had their training

chips, Google had their TPUs, Nvidia had

GPUs, Meta and Microsoft, they had their

attempts but struggled. And now who's at

the top of the leaderboard? Who's

leading the race? It's OpenAI because

they didn't build the chip first. They

used other chips, GPUs to train the best

model, the best coding model. And now

OpenAI is very independent. They're a

full stack company now. They have their

own chips, their own models, they have

their deployment, product experiences,

user base. So in conclusion, AI will eat

everything and we're watching it happen

live. Let me know what you think about

this whole thing. I'm still kind of

processing everything. I'm still trying

to kind of understand what the heck

happened. I mean, I've said things like

this would happen. I've predicted some

things like this. Not this specific, but

we've talked about AI models, developing

hardware and chips. Like, we we've

talked about all this. And still, when

it's here and in your face, it it's

still kind of shocking. You still don't

expect it to be this blatantly good and

for it to get developed this blatantly

fast. And I knew it was going to be

fast, but now that you're seeing it,

you're feeling it, you're like, whoa,

dang. Like, this is getting nuts. So,

with that eloquent speech at an end,

I'll bid you a due let me know what you

think about this whole thing and what do

you think about Nvidia? How is this

going to affect them? Let me know in the

comments. Thank you so much for

watching. My name is Wes Roth. will see

you in the next