So a few days ago I opened up Curser.

As always, I went and I switched my model here to opus 4.7,

and I started giving it a bunch of instructions and getting it to build out an app for me.

Now, after about 2 or 3 hours, I actually ran through all of my usage

of the high end premium models here and actually unknown to me.

Cursor switched my model to composer 2.5, which at the time was even still.

Now is their brand new model that they just released.

Now, I didn't know that this switch had happened, or I didn't see it in the UI

until I realized that all of the things I was asking cursor do were happening 3 or 4 times faster,

and the results that were getting was pretty much the exact same as what I was getting before.

With opus 4.7.

If not even a little bit better in terms of the structure of the output.

So I actually dug into this. I was like, why is this so much faster?

I realized that it had switched me over here to composer 2.5,

and then I started looking into this new model and just using it for the next 2 or 3 days.

And what I realized is that this model is as good, if not better than all of the frontier models.

We're talking opus, we're talking GPT 5.5.

And I don't know why more people are not talking about it, which is why I'm making this video.

Now, I actually just had composer 2.5 whip up a quick presentation so I can go through this to you,

but what I'm going to do later in the video is show you a real demo.

So wait for that if you want to see exactly how it works.

But the main significance here is that cursors new composer model is almost

as good as all of the frontier models, but at a fraction of the cost.

That's why I put it on the homepage here.

It costs $0.50 per task using the composer model, versus

$7 per task using opus 4.7 on the exact same benchmark.

This is not scientific.

This is just cursors own benchmark.

The thing is, this is 14 times cheaper, at least in this test,

and in my tests it's much cheaper, it's much faster, and it runs just as good.

So I'm going to go through all of the key benchmarks and give you all of the data,

and then we'll get into a live demo so you can see what I mean.

Okay. So let's go through this here.

Cursor is just winning on every front right now.

They have a great model.

They have the best a genetic coding harness which I want to talk about later.

And they're just one of the most pleasant tools to use for real software development.

Even if you want to use opus, you want to use GPT 5.5.

You will get a better result using it inside of cursor because of the harness

the cursor has developed.

And if you're unfamiliar with what a harness is, I have a whole section on that later.

The clawed code codex kind of right cursor.

These are harnesses.

These are tools that are built around an LM and cursors harness

objectively is just better than pretty much all of the other ones that are on the market.

Which is why, in my opinion, it's really winning the agent development race.

So if we go through a few stats of this model, you can see that was released

May 18th, just eight days from when I'm recording this video.

It was based on the Kimi k 2.5 checkpoint, or at least that's what they modeled it off of.

And then this is the same base as composer two, which is the previous model they had.

That was also very good.

That was released in March, except this one obviously is significantly better if we keep going.

There's a few other stats you can look at here in terms of the parameters, inference, all of this

kind of stuff.

I'm not going to bore you if you don't know what those mean,

but pretty much this uses a mixture of experts architecture in the background

and had kind of interesting compute and training split.

If you're interested, look it up.

I'm not going to bore you with all of the details.

Okay. So let's go through a few of the benchmarks here.

First, I have a third party evaluation benchmark.

This is the artificial Analysis coding agent index.

You can see that it's practically tied with opus 4.7 and GPT 5.5.

If we keep going and we look at a sweep bench multi-lingual, you can see that

it is very similar performance.

In fact, even better than GPT 5.5.

If we have a look at Cursor Bench V3, point one, of course it's going to shine here

because this is cursors own benchmark.

But we can see it outperforms the field.

And then if we look at Terminal Bench 2.0 it's pretty much the exact same as opus.

And then of course GPT 5.5 is still leading by quite a bit.

So if you still want to do shell heavy work, probably you're going to go with that.

But still very, very impressive.

And the most impressive part is the cost, right.

This is a significantly more efficient model.

It is way cheaper.

It is way faster as you're going to see.

And just in their comparison here, when they were running this on I believe it was

the cursor benchmark.

The cost per task was $0.50

for a composer 2.5, and nearly $7 for opus 4.7.

Now, I don't know what the value was for GPT, or I didn't put it in this presentation.

I imagine it would be less.

But still,

if you were just to look at this, you would imagine the model is going to be significantly worse,

but it's not.

If anything, it's lagging by 2 or 3 percentage points,

which really isn't noticeable in real world coding tasks,

especially when you want to get something done fast and when you want to have usage left

for the next day, which you just can't say when you're using these high end anthropic models

unless you're extremely rich.

Now let's keep going and let's talk about coding harnesses,

because this, to me is actually the more interesting kind of part of the story here.

When we talk about cursor, if we just talk about these raw models, right.

It's like giving some text input and giving some text output.

Your frontier models are still going to perform better than something like a composer two point font.

Now that's because these are more general purpose models.

They're not just used for coding.

And well, when you just use them from the base API, you just generally get a better response

because they have more training data and they're just more designed to do that.

However, when you want to use these models in a special task

or specialized use case like coding, you're usually not just using a raw API.

You have context management, you have skills, you have tools, right?

You have sub agents, all of these different things.

And those get wrapped into what we call a coding hearts.

Now, Claude, code that's a coding harness.

When you use cloud code you're connecting to MSPs.

You have this context management going on.

You have tools in the background that are being used that you don't even know about,

to search for files and find context and information.

Now cursor is also a coding harness.

When you go and you load up opus or you load up compose or you load up

GPT inside of cursor, you're using cursors harness,

which means the way the context is being injected, the way the tools are being loaded,

the way that skills are being presented is actually being controlled by cursor.

And cursor has a really good harness to the point where

if you actually just bring in any of these models that you would use outside.

So GPT 5.5, ops, whatever, and you run them inside of cursor, you're going to see

that you get a better response because cursor has spent more time optimizing their coding harness.

And that means that when you combine their really good harness with now, they're really good model.

You get an even better result because they kind of mesh and have their chemistry right.

It just like what Apple silicon runs really well on MacBooks because it's designed to do exactly that.

It just to give you a bit of a better visual, you can have a look at kind of a quick graphic

on what a harness actually looks like.

Now you can see that this is really the orchestration layer, right.

So context looping tools

and then actually connecting and reading your code like I was talking about before.

The model is really just one part of this entire equation.

Now it's the brain. Sure.

It's really what's needed in order to do anything or come up with any creative work,

but the way that the model functions is completely dictated by the harness that's around it.

Because again, all a model can do is just predict text.

That's literally all it does.

You give it a text in and it will give you some text.

So we need to control what text goes into it.

And then we need to provide things like tools to the model.

So if I have a really good tool in this harness, but I don't have it in another harness,

my model can perform better just because of the quality of the tools that it has access to.

If my looping and failures are a lot better in one harness, I'm going to get a better result

because I'm going to fix all of these errors proactively and have the model

run multiple turns right, or do more things than it would do in another harness.

I'm being super vague with how I'm describing this, but Curser

has really set themselves up from the beginning to be the best harness.

They fine tuned everything.

They've written, the best descriptions, they have, the best system prompts,

they have the best context, engineering and indexing of your code base.

And this allows them to give you a much better result when you're coding, regardless

of what model you're using.

Because the tools, the infrastructure, and the orchestration around it are simply just better.

And if you don't believe me, go and use Claude code on a project and then go and use cursor.

And I guarantee you you will see a noticeable difference, even if you use

the exact same model at the exact same sets.

Again, the model is just predicting text.

All of these other things really are that full picture.

And I'm going to make a full video on this later to break it down more.

Anyways, point is harness is really important.

Cursor is a really good harness and that's why I think it's important to talk about this.

And just as I was discussing here, the model is the engine.

The harness is the car.

Doesn't matter how good your engine is if it's in a shitty car, right?

That's just the analogy to go with.

Now, like I talked about, cursor didn't just ship a model, it fine tuned the harness around it.

So not only do they have composer 2.5, but they have the specific coding harness which is the cursor

application fine tuned around that model, which just gives you this really good result.

Now, because I know a lot of you guys are going to ask this.

Yes. The site that I made here was built using composer 2.5 inside of cursor.

But you'll actually notice that I have it deployed here to a public here

now to main, which was entirely free that I didn't need to pay for,

and it required pretty much no setup at all.

Now here, Right now is sponsoring this video and has been sponsoring my channel, but

I love mentioning them because you literally don't even need to make an account or pay for anything.

It is completely free.

The way that it works is you literally just copy the setup instructions for your AI agent.

You paste it to your agent and you just say, hey, I want to deploy this site using here

dot now, and it just figures it out for you and deploys the site to a URL

so you can see that I did that here. I said deploy this using here to now.

I gave it the setup instructions and if we scroll down install the skill

and then it just deployed it to this URL which we're on right now, which I can now

share with anyone to share this presentation of that you guys can access.

And then by default it will be available for 24 hours.

If you want to claim the site and have it be available permanently forever.

Again, you don't need to pay for anything, you can just claim it and connect it to your account.

So you make it here dot now account.

And then it will just save the URL permanently so that you're able to access it

and is connected to an account.

You can do this for literally hundreds of different websites.

It is the fastest, easiest way to deploy something, especially if you just want to send it

to someone for testing and you can set up all kinds of additional stuff like secrets.

You can claim domains, you can have a drive, variables, API keys, all of this kind of stuff.

I myself have deployed many different sites and that's why I'm happy to have them

as a sponsor of this channel, because they think it is a genuinely really cool tool

that all of you guys can use if you are using AI agents.

Now, of course, I believe you can upgrade and you can get, you know, like a $4

per month plan if you want thousands of sites or a developer plan.

But I've never needed to do that.

I just use it for free and I'm always happy to share with you guys.

Check it out from the link below.

It's literally just here dot.

Now you can deploy sites for free.

Okay, so now what I want to do is get into a live demo and show you the speed difference.

Importantly and the quality difference between composer 2.5 and a model like opus or GPT 5.5.

So I have two cursor applications open on screen.

On the left hand side, I'm going to be using composer 2.5 in fast mode,

and on the right side I'm using opus 4.7 in medium fast.

Now, in order for me to use the fast mode here, I did need to enable the max mode in cursor,

which now means that I'm going to be paying six times the default price.

So we'll look at the credits and usage afterwards to see how much this actually ends up costing me,

because it's going to go on extra usage on my plan, but I want it to be fair and do two fast mode

comparisons rather than just comparing to the default opus one, but we can look at that as well.

So what I'm going to do is just paste in a prompt.

The prompt is build a production ready real time collaboration

whiteboard web application similar to a simplified Miro or Excel a draw

the application must support multiple users end to end editing, the same board, etc..

Okay, so I'm going to paste it in both of them and just hit enter at approximately the same time.

And we're going to see how long this takes.

Obviously I'll fast forward through it using both of these models and overall

kind of the result that we get now, the more scientific comparison.

But I just want to show you quickly what we're looking at here in terms of the side

by side comparison on one model that is going to be, in this case, like 20 times

more expensive than the other.

Okay, so already here composer's going and it's starting and it's working on the application.

It's writing code.

Whereas opus still hasn't started doing anything yet.

Yes, it's in thinking mode.

So maybe it's coming up with like a more clever plan

or something, but it's like randomly, for some reason, checking the workspace contents

while this is already going and just spitting out a massive amount of code

and you can see, you know, 120 line files pretty much instantly being completed,

whereas opus hasn't even started writing any code yet.

Again, not the whole scientific response, but I'm just trying to show you the speed difference

that we're looking at here, because this is drastic to me,

and I felt this a lot when I was doing my own coding projects.

All right. So composer just finished here.

I don't know the exact time, but it looks like it was maybe 3 or 4 minutes to execute this.

And then if we're looking at our, what is it, opus version

on this side, it's still going right now it's running the dependencies.

It's trying to test everything. So we'll see how long that's going to take.

So for now it looks like this is running.

Let's actually just open it up.

You can see that okay. That's pretty impressive.

Let me see.

Can I open multiple of these.

So that's going to be I guess the key Distinguisher.

So let's run this and put it over here okay.

It looks good to start.

And let's see if I draw okay.

If I do a circle, if I do a stroke okay.

Whatever.

Let's just mess around with a bunch of different stuff here.

Let's add some text or something.

I don't know how the text one works. Oh, I got to do text here.

Let's see.

Text and edit this hello world.

And you can see that it's happening in real time.

And obviously on localhost it's quite fast but you get the idea.

So I mean that's pretty good in the first run here

of this application and probably is a bunch of other stuff that I'm missing.

I can zoom in, zoom out, and it actually shows where I am on the other screen, which is super cool.

Okay.

So I mean, that just essentially one prompted that application.

Opus is still running right now.

So just to be fair, let's stop this dev server just so that

it doesn't have some issue running it, and let's see how much longer it takes for opus.

Okay, so opus finally finished.

I was actually getting impatient relative to composer here.

I think we're at at least 15 minutes.

We're again with composers maximum like four, and it didn't even run the application for me.

So I'm just going to say run the app for me because it wasn't doing that.

Even though composer did that by default.

It's giving me the instructions.

So let's see if it can run it.

Hopefully it will spin up the shell and then we can test it and see if it works.

Now, one thing to note, because I was just looking at the code,

given that I just had to sit here for 15 minutes, is that if we look at the opus version,

we actually get it with pure CSS JS so no TypeScript, it's not using react.

Yeah, we have a server and whatever separated out it looks like at least

the structure is somewhat decent in terms of all of the different files.

But then if we go and we have a look at our composer version,

we can see that this actually used a separate client,

a separate server, it used react for the client.

You can see with this let me close this here kind of app.

Dot of main dot.

All of this.

Again we have some folder structures here hooks lib canvas.

And generally the structure is as good if not better than the what do you call it here.

Opus version on the right hand side for the server.

I mean it's a little bit barebones.

What we've got going on here in terms of the WebSockets,

it looks like it's just transmitting like all of the data.

So that's probably an issue if I look into that a little bit deeper.

The point is that at least proactively went with TypeScript, whereas this one just went with pure JS.

Okay. So it's saying let's check this out here.

So let's go to the demo one.

What is it saying to go to let's go to be my board okay.

And let's open this twice and let's test it and just do a sanity check and make sure that this works.

Okay. Here we go.

Paste this and let's try to draw something.

Can I draw

okay.

And it looks like unless there's some issue that I cannot do

anything share maybe link.

So work.

Yeah.

Like, I cannot seem to do anything at all.

Like it just completely broken.

So that's great.

I waited 50 minutes for all of that.

So I'm not going to try to debug this right now.

But this is kind of what I'm talking about guys, is that yeah, we think opus

or we think these models are the best,

but then something like composer comes out and just completely tears it apart.

And sure, this is just one experiment.

Of course it can make mistakes.

It's not a scientific method I'm showing you right here, but I have this in opus 4.7, medium

fast mode, where I'm paying probably 2025 bucks what I should be for this model to run.

Meanwhile, we get a better result in four minutes, right?

That actually functions from this extremely cheap composer model.

So just to be fair, let's switch over now. GPD 5.5.

Give it the same prompt and see what we get.

Okay, so we just started running GPT 5.5.

I just made a full screen here. You can see I'm doing medium fast.

So same thing I had to put in max mode.

So again I'm going to spend an arm and a leg to run this here inside of cursor.

But hopefully this is going to give us a functioning response.

Let's see.

All right. So Codex is wrapping up now.

Now this is taking a long time as well I think we're at about ten minutes at this point.

So a little bit shorter than opus but still taking a good amount of time.

I will say, however, that the code quality that we're getting, at least at first

glance, is significantly better than what we had with all of the other models.

I just skim through some of the files.

It did use react and TypeScript.

By default, the server looks a little bit more complete in terms of what it's actually doing.

We have shared types, we have automated testing.

And just again, me quickly going through this is not a scientific analysis here,

but even just looking at like the board and all of these different things,

it seems like this would be a more maintainable application overall,

and at least at first glance for me is a little bit more understandable.

Now it's also running the tests automatically,

making sure that everything is going to work, and then hopefully it's going to spin up the app.

So once it spins it up, we'll test it and see if it does actually function.

But at first glance, I'm feeling a little bit

more positive here with the GPT and or with Codex or whatever you want to call it.

I guess it's just GPT because we're not using it in the Codex app, and same thing as before.

I'm using the fast mode in a medium effort, which I think is kind of a fair analysis.

Okay, so a few minutes later and it looks like this is working now,

so we can do a rectangle, we can do an ellipse.

If I go here we can do a sticky note okay.

And just place it on screen I don't know how I'm supposed to like zoom in on this.

Because that doesn't really seem to be working.

And it looks like, yeah, we can add text box.

Okay, let's go back here to select.

We have a name that I guess we can update.

So overall it's not the most clean version of the application,

but at least it's functioning unlike the version that we had with opus here.

And in terms of the time

analysis here, this took a similar amount of time as opus after I told it to run the app,

and it was doing all of the testing and all of this, at least we're getting something functioning.

But still my favorite version of the app.

So far, at least in terms of just initial function, is the one that we had with composer.

Now, I didn't know that was going to happen when I ran these prompts.

I've been ran these before.

I'm not trying to be biased towards one particular model.

In fact, I would hope that these models would perform better, but it doesn't seem that that's the case.

Now. GPT does seem like it has a bit more reasoning, a bit think a bit more thinking.

It's trying to structure the app in a bit more of a clever way.

So I appreciate that in terms of the way that it structured it here.

And I'm sure with a few more prompts, I could get it to give me a much better result

if I told it more specifically what I want, but overall a little bit disappointing compared

to what we got with composer in like five minutes, whereas this took like 15 or 20 minutes to run.

So anyways, guys, that's going to wrap up this video.

I wanted to show you how good the composer model is,

how cheap it is, how well it works inside of cursor, and encourage you to use it.

I'm not biased towards

any one of these individual models, I just want to use whatever one is the best I found.

It works really well for me, so hopefully this gave you something to chew on

and let me know what you think of the composer model and your experience with it,

and I will see you in another video.