You see that face? You know what that

face is? That that is the smug face of

somebody who was proven correct. And the

best part, it's right after caught in

8K. You're even told by your friends

you're wrong. So, you're probably

thinking, "Okay, what what are we

talking about? What are you even trying

to say? What were you proven right

about?" Well, my friends, it turns out

after many hurt feelings and being told

I was wrong, images might actually be

better for models than text. I knew it.

Don't make it do image recognition on

that, dude.

>> No, no, you just do this. What are you

talking about?

>> Hey,

>> now this isn't just me saying this, of

course. This is actually DeepSeek

releasing a new paper that suggests that

if you provide images, you could pull

out 10 text token from a single image

token with near 100% accuracy. In other

words, a model's internal representation

of an image is 10 times efficient as its

internal representation of text.

Meaning, not only do you get the correct

information out, that you also get it

way more efficient. And I know I know a

lot of you right now keep running up

against limits with Fable. Okay, you get

like one prompt into it and you're like,

I'm already out. Maybe, just maybe, this

is the balm you need to apply to those

Fable wounds. What a what an analogy.

There's also been a bit of research into

this, apparently claiming that yes,

you're actually going to get 59 to 70%

lower end to end bill by using images.

And yes, I myself even did a bit of

research, spent 2 billion tokens for

this video. Hey, that's dedication. All

right, so before we get into the

nitty-gritty details, I would first like

to say thank you to my sponsor, Hkins.

>> Dad, could you teach me how to code

today? Doesn't look like I have time for

that, son. My database is down again.

>> Oh, maybe tomorrow.

>> Not again.

>> Go long, son.

Teach, got to go fast.

>> Hey teach, how do you have time to play

with your kid? Isn't your database

always down?

>> What do you mean? I chose Planet Scale.

The database for the consumer who wants

their downtime to be with their kid.

>> Nice catch, son. Thanks for choosing

Planet Scale. You're the best dad ever.

>> No studies have confirmed Planet Scale

makes you a better father, but it is a

really good database.

Sorry, I was just feeling so vindicated.

I just had to keep on making that face.

So, this blog post by Shawn Geodec goes

in and goes into quite a bit of detail

about why these things can happen and

even gives an example by George Mandez

here about other fun ways you can

compress data and send it off to Open AI

or any of these model providers. And

this one involves just simply running

your audio through FFmpeg and just

speeding it up by two to 3x. you will

save massive amounts of tokens and it

gets the same results. Okay, so back to

the images. Why would images work better

than text? So with text, you say exactly

what you want to say. It can input and

process each one of those tokens and

moves on, right? It that seems rather

simple. Whereas with images, doesn't it

have to do a bunch of processing? How is

this not using a bunch more tokens? So

here's his basic explanation. Optical

compression is pretty unintuitive for

many software engineers. Why on earth

would an image of text be expressible in

fewer tokens than text itself? In terms

of raw information density, an image

obviously contains more information.

Goes on to kind of say like, hey, hype

out the word dog. It's way bigger in an

image, right? The first explanation is

that text tokens are discreet while

image tokens are continuous. Each model

has a finite number of tokens, say

around 50,000, and each of those tokens

correspond to embeddings of say a

thousand floatingoint numbers. The text

tokens thus occupy a scattering of

single points in the space of all

possible embeddings. What he's trying to

say is that just imagine a floating

point somewhere between zero to one and

you have a thousand of them and you

could have so many different variations,

right? An infinite number of different

variations. But with text tokens, they

actually have a concrete discrete value.

One text token to a single, you know,

combination of a thousand floatingoint

numbers. Thus, there's only 50,000

possible representations you could have

in an infinite space. So very, very

unoccupied space. By contrast, the

embeddings of an image tokens is any

sequence of those thousand numbers. In

other words, it's continuously through

that. They can have all sorts of

different variations. Me much much more

data can fit into those thousand

numbers. So, an image token can be far

more expressive than a series of text

tokens. Another way of looking at the

same intuition is that text tokens are

really inefficient way of expressing

information. This is often obscured by

the fact that text tokens are reasonably

efficient in the way of sharing

information. meaning me and you can send

messages to each other and that makes

perfect sense. But for an LLM that's a

little bit different. So long as the

sender and receiver both know the list

of all possible tokens. When you send an

LLM a stream of tokens, it outputs the

next one. You're not passing around

slices of a thousand numbers for each

token. You're passing a single integer

that represents a token ID. But inside

the model, this is expanded to a much

more inefficient representation.

Inefficient because it encodes some

amount of information about the meaning

and use of the token. So it's not

surprising that you could do better than

text tokens. He also makes an argument

about the brain how you know when you

look at a word even if the letters are

slightly mixed up you can still just

read the word and so that humans

actually operate more on images is the

general argument and sets LLMs are

supposed to be some sort of

representation of our brain therefore it

works. Uh I'm not really into brain

comparisons. Uh, I'm not quite sure if

we even know how exactly the brain

works. And so not knowing how something

works and then comparing it to something

we also don't really know exactly how it

works is not necessarily the greatest

way to uh to make an analogy for me. But

anyways, I DIGRESS. I DIGRESS THERE for

a second. To me, this actually just

makes sense and I think it makes much

more sense looking at this. If you just

look at this image for one second, this

is an error from the compiler in Rust.

you immediately know what went wrong and

how to fix the error. You don't have to

read all of those text tokens to be able

to understand what's happening. There's

something kind of magical about images

because they encode so much more

information than you realize. And this

is obviously like pointing a gigantic

arrow and saying, "Hey, here's the thing

you should look at." And then this right

here is also another gigantic arrow

being like, "This is the solution." So,

one can imagine that the image itself is

actually encoding significantly more

information, thus giving these models

more context to operate on, thus having

better results. So, I thought I would

give it a little bit of a try. I took my

entire context file for my game that

I've currently am using. It's not the

best context file, honestly. I think I

could do a lot better, but it is a

context file nonetheless. And I shoved

it all into a singular image. I'm using

something called PX Pipe, Pixelpipe in

which apparently they're using it with

Fable and this is the one that I was

saying does 59 to 70% lower endto-end

bill. They have a whole bunch of

information about this saying, "Hey,

it's actually much much better that

Fable 5 is actually operating just the

same that they're able to produce it

with a lot less money going in and out."

I mean, this obviously sounds pretty

good, right? Well, I wanted to see does

it actually make a difference. And what

did I test it on? Well, I tested it on

my video game that I'm currently making.

So, as of right now, we're actually

having pretty decent uh progress into

the game. I can't believe I got Lonely

Tower enhancement. Off the rip. Let's

go. Oh my gosh, my tower is going to do

so much uh damage right now. Don't worry

about this, okay? The polish will come

later, but this is just a simple tower

defense game with ammo, with levels,

with enhancements, with stat tables, all

the fun stuff that you can throw on

these and energy and all that. And I

have a file that effectively just

basically describes what's happening and

how you play the game. More than just

that, I can also play the game in JSON

mode. So right now it's running. It's

letting you know it's ready. It's

actually running the full game

experience. The only difference is is

that it's running it in JSON mode. It's

not running it in ray rendering to the

screen mode. So if you want to move the

mouse, you have to send in a mouse

operation that says, "Okay, this is how

I'm going to move." And if you do that,

it just works. It actually moves the

mouse and flows through the whole

program so the AI can control it through

what appears to be something like MCP.

So I ran two experiments. I effectively

let the game be played by these models

five concurrently on my system just

running non-stop playing the game over

and over again for a couple hours. Now

these models are very slow at playing

the game. So on the context as string we

had 50 successful games. Of those here's

basically the stats breakdown. Now, the

thing you really want to look at is

time. I think time is really, really

important here. On average, it took

about 9 minutes to play the game. Okay,

that's pretty good, right? Second, you

can see how much overall damage it did

starting from the 10 percentile all the

way up to the 90th percentile. And of

course, max. And you can see that it did

a decent amount of damage. It ended up

letting out uh so many enemies through

before dying. It also had this many

shots taken and hit, this much criticals

being done. So overall, it did pretty

good, right? I I'm happy that I could

see this. This right here means that it

played the game really, really smart,

meaning that it actually took a tower

and placed certain cards in a very

specific order, thus maximizing the

damage. So a good percentage of the

time, it actually made it to the point

of maximizing the damage really, really

well. Now, if we look at the context as

an image side of things, I only got 23

successful games. And the reason being

is if you look at the time, the time was

outrageous. Minimally, it was like 20

minutes on a game. The average time was

about 20 minutes on a game, and some of

the upper games were taking 30 minutes

to play through. It was just

significantly slower. But if you look at

the damage, the damage isn't really that

much different. It's lower on the max

side and it's pretty much higher all the

way through. So, it took a lot longer,

but it did a lot more damage. But the

weird part is these things that I'm

trying to take out, which is the amount

of enemies that reach the end before you

died. meaning that a lot of enemies

reached the end and had just higher

amounts of health, thus doing more

damage, thus killing the uh person much

much faster. And so it's like, okay,

what can we really glean from this?

Well, they have about the same amount of

hits, so that's not really much

different. The damage is near similar.

Everything was about near similar except

for the time. The time seemed to be

horrible. And so my personal guess is

that through the discovery of the server

and maybe some light processing of the

image, it was able to piece together,

yes, I'm playing a tower defense game.

Yes, I kind of know what I'm doing.

Therefore, it just went and played and

it kind of could guess its way through.

And I don't think it did nearly as well.

And I think the time indicator is really

what is kind of telling the truth here.

every single game just took massively

longer and I just didn't complete nearly

as many games because it ended up being

like four hours of running and a lot of

tokens. And here are the statistics that

I actually got out from cursor itself.

As you can see, the full context as a

string had uh 324 events, 286,

a bunch of tokens used, 306 million. The

total tokens for the image context was

only 213. Now remember, I played well

less than half of the game. So again,

what can I draw from this data? What I

can draw from the data is that it's

actually probably much harder and much

more confusing to actually use this

strategy. And you would probably want to

do a bit of experimenting. For me to

even get to this experiment, I had to

spend about 1.5 billion tokens in just

experiments to at least verifiably prove

that things were going the way that I

wanted them, that uh actual games were

being played, that you know, the

objectives were being had. So, at the

end of the day, should you just go rush

out and listen to Twitter and convert

everything to to images now? Probably

not. But there actually could be a world

where this actually makes a lot of

sense, where a lot of good things could

happen if you do it. And so, like all

solutions that you hear on the internet

and all of the Twitter excitement, it

always comes down to the classic senior

engineer response. It depends. And you

probably need to do the homework

yourself. So, please don't just listen

to every last cool thing that's thrown

across the internet. Instead, try

things, experiment, look for

optimizations, because you never know,

maybe there's something super duper

cool. And also, just to be real, like a

lot of these technologies, they're

designed around text. Their primary

input is text and all that. And so,

maybe there's an entire world where

caching and all this other stuff just

isn't optimized yet for images. So, even

if you are getting a win, maybe a much

larger win could be coming down the

pipe. If only we just wait a little bit

and this technology is used more. So,

you know, it's really really hard to

compare these things because it is a

very kind of almost apple to oranges

comparison. All right. Hey, the name is

the primogen.