If you’d rather see this as a video, there you go:

https://youtu.be/llBOR_eSvuM

If you prefer reading, go on.

How Did I Make Agents Pay?

The blog you’re reading right now at https://dragosroua.com is a static site. It’s built with astro, which pulls data from my old WordPress engine (I still add content there). Every build generates an .html file that’s served indiscriminately to everyone: humans, Google index bot, AI agents.

I added an extra step in the astro build process, that takes the content I’m getting from WordPress, and turns it into a stripped down markdown file, just the title, the publication date and the body. So now there are 2 files with the same slug, but 2 different suffixes:

blog-post.html (technically, this is blog-post/index.html, but that is not relevant for now

blog-post.md

Now, if an agent takes in an .html file, it still needs to do some parsing to get rid of the HTML tags, CSS, header metadata, javascript snippets, etc. This consumes some tokens. On the other side, if they just get the .md, they already have the content, no need for parsing.

On average, a model consumes 3x more tokens for HTML content than for markdown. On an expensive model (Opus, Astra, Grok) this may come up to $0.01.

So, I hid the .md file behind a x402 paywall (402 is actually part of the http specification, it was around since all the other codes: 404, 301, etc. Only recently there were actual implementations on the protocol, and the most popular one was launched and supported by Coinbase).

So what happens now, is that the agents are having a conundrum:

• parse HTML and spend a variable (not known beforehand) amount of tokens
• get the parsed .md and pay $0.01

The signal for this is given in the llms.txt file, which is a specification followed (in theory) by all agents. They read that file, and they understand how they can consume my site. Links inside llms.txt used to be all HTML, now they’re pointing specifically to the .md files.

Of course, not all of them are complying, and I’m not expecting all agents to pay now, but at least I’m trying. I’m sending the right signal, showing that the data is served on different levels, that it has some value, and that it comes with a bit of convenience – being already stripped down in a format AI agents understand.

I travel a lot and I want intelligence on the go, on hardware I actually own.

This video below is my short answer to: what “open weights” really means, how much RAM you need, how quantization works, and my very own shortlist with models from Europe, the US, and China.

https://youtu.be/sYUr3pVbbX8

Watch the video if you want detailed info, if not, here’s the TLDR:

My shortlist as of September 2026

1. Qwen 3.8 27B — my “download tonight” all-rounder
2. Google Gemma 3 (4B / 12B / 27B) — start small, scale up
3. Mistral Magistral Small (24B) — Europe’s practical open option (and a bit of a surprise)
4. NVIDIA Nemotron Light / Lightning — if you already have an NVIDIA GPU
5. Meta Muse Glimmer (~30B distilled) — fallback when you have ~32GB+ RAM On a stronger Mac (often 64GB+), DwarfStar from antirez can push you into DeepSeek V4 / GLM 5.3 / Qwen territory that would otherwise want DGX Spark-class hardware.

General hardware requirements: you’d want a silicon Mac (Mac Book Pro or Mac Mini Studio) or an Nvidia based Intel machine (DGX Spark, Framework, etc). Memory rule of thumb: 16GB barely fits and it’s a basic start, 32GB you can actually do useful things, more is always better. You’ll almost always run a 4-bit / 3-bit / 2-bit quantized, not the full file that the labs released.

This whole thing is not only about speed, or tokens per second. Local means your prompts, chat history, and cache stay on your machine. You can run inference even without the internet. This time around, the ban on open source failed, but who know, it may succeed in the future. Knowing how to set up your own local AI is your insurance against this.

There’s also a full series about how to choose an open weights model in general. You may want to start here: How To Choose An Open Weights Model – Episode 1

And for more benefits: Running Local, Private AI Models, When and Why.

Bad guys get the juice. And the apples. And the juicer. They get everything because they don’t treat this like an emotional whirlwind. They treat it like a battle that has to be won, like a field of limited options that you have to narrow until the only remaining one is victory.

It’s really the same car, but 2 driving styles. The car is AI, and the way you drive it shapes what you get out of it.

AI is not smart. It doesn’t “reason”. It’s just an incredibly complex statistical approximation engine. It does not know your idea, your use case, your expectations. It just follows what you prompt it into, and it starts narrowing the path to get close to what you described.

A huge GIGO playground: Garbage In, Garbage Out. If you give it vibes, you get back vibes, if you give it the results you expect, you get results.

The good guys get back vibes.

The bad guys get work done.

Bad Guys Are Building

The vibe coding team starts by describing an idea. Soon, they overwrite it with a feeling: “make it look nice, I want a beautiful app”. Guess what: the model describes the feeling back. Suddenly, you feel accepted, understood and all that nonsense. For a few hours you are in love with an engine that literally cannot know who you are.

Then 6 hours later you stop talking to the agent. Your chat vanishes, the feelings inside it too, and the only trace of your app idea is in the code. And the code is awful. First, you have no idea what’s inside. Second, you have no idea why something is inside.

Bad guys are a different breed. They have witnessed at least one database crash in production. They know why and how it happened, they know what to do to avoid it next time.

They also know why people who successfully shipped on a Friday and unicorns belong to the same category: both are mythical creatures. They don’t exist in the real world.

Bad guys never tell the agent how it should “feel”. They tell exactly what the agent has to do, period.

• what must happen. -what must never happen.
• which section owns the truth.
• what stays local and what’s in production.
• how we know we’re done and how we accept the work of the agent.

Bad guys write their own harnesses. They’re token-aware and they know how to squeeze every bit of power from what they have. They don’t spend thousands on API tokens. Most of them keep their spending under $100/month.

Bad guys know the approximation engine has limits and they enforce them. They use context sparsely and keep only what’s needed there.

Good Guys Are Getting High

Good guys splurge on long conversations and detours of why that tiny feature reminds them of their childhood madeleines.

Good guys will choose the latest, flashiest tool and then brag about using it ten times on Twitter, before even firing it. Then, after they fire it, they post again, this time with screenshots and detailed descriptions of intense vibe coding sessions.

Vibes feel good. You talk to a machine that seems to understand you, to follow your orders, to bring to life that vague idea that was floating in your mind for years. It’s like you’re getting high on your own dopamine.

But the higher you get, the harder you crash.

After the first MVP, you get into a maze that’s impossible to navigate. You change one thing, four other things break. You ask the model to fix the bugs, it introduces a fifth source of truth and 3 more helpers you never asked for. You suddenly have 500KB of markdown files in the app folder.

You cannot blame AI for this. You just gave to an approximation machine your approximate thoughts and it just destroyed your approximate expectations.

To get out of this deadlock, good guys will keep prompting until the machine “straightens up”. Descending into a downward spiral of frustration.

Bad guys start by writing the test case, so they never get high. They never have 500KB of markdown files in the app folder. If anything, sometimes they get bored, because winning is so predictable for them.

Good guys vibe code. And they live in the friendzone forever.

Bad guys write specs. And they ship useful stuff.

You never get predictable outcomes by sharing with a statistical machine how you feel about it.

You get them by describing exactly what needs to happen before you start crunching tokens.

If you’d rather see this is a video, there you go:

https://youtu.be/5paPD41fC2o

If not, keep reading:

The context of the essay counts too. Two days before the essay, a former employee posts on Twitter that he quit over the dangers of AI. His new account’s first tweet does a few hundred million views. John Ternus got a million on day one. So this was definitely NOT organic traffic. Then mainstream media follows up with WSJ and CNN stepping in. And then the essay.

The second thing he states clearly in the essay is a crackdown on open-source models from “autocratic countries.” That means China, because those weights got really good.

He does not say what happens to American open source like Meta’s Muse, Nvidia’s Nemotran, Thinking Machines or Poolside. So the rule, as written, is: stop their open source, keep ours. That doesn’t sound like a safety framework. It sounds more like a market request. Like a monopoly.

Put the two together — train, don’t distribute, and close the open lane — and you get a small number of labs holding the weights, the eval stamp, and the contracts.

There is an IPO coming up and if their products can be outpaced at 95% less, then the IPO is basically void.

I don’t know if the listing happens.

But I do know I would rather keep the open source models I can actually inspect than wait for permission to use the ones I can’t.

Programmers are realizing that instead of paying $20 or $30 every month for some relatively simple SaaS, they can now vibe code their own, customized version.

Need a tiny web scraper for your news service? Build one. Need a tiny dashboard for your SaaS analytics? Cool, just build one. Need some obscure tool that does exactly one thing? Build it over the weekend.

So far, so good. It’s nice to have this flexibility But then the argument goes a little bit overboard:

If everybody can build their own software, apps will disappear.

I don’t buy it.

In the video below I explain my point of view, and also bring 2 of my apps, Shape Walk and AI Kiddo as examples.

https://youtu.be/uNIfTkCUPN0

If you’d rather get this as a blog post, just keep reading.

I’ve Seen this Before

Twenty-something years ago, having a personal website required quite a bit of knowledge: some HTML, how hosting works, in general you needed to understand how to actually put the thing online.

Then WordPress happened. Suddenly you could click a few buttons and have a website.

Did the website business disappear? Nope. Maybe the opposite.

An enormous economy appeared around WordPress: themes, plugins, hosting, consultants, agencies and businesses that couldn’t have existed at that scale before.

I think AI and vibe coding will do something similar to apps.

Some Apps Will Disappear for Sure

This doesn’t mean nothing changes. There is an entire category of apps that is vulnerable: generic calorie counters, simple scrappers, any thin interface around something you could reproduce with a few prompts.

If an app has no differentiation beyond performing a simple function, AI is going to put enormous pressure on it.

That layer may indeed disappear. But that’s not the same as saying ALL apps will disappear.

Here’s the kind of apps that I think will survive.

The Apps that Are Personal

I have a small app called Shape Walk. You draw a shape over the map of your neighborhood and then walk that shape. The app guides you through the waypoints, tracks the walk and saves the result. It’s part fitness app, part GPS art, part game.

Could somebody reproduce its functionality? Of course. That’s actually beside the point.

The interesting part is the experience, your history inside it and the repeated relationship you develop with the product.

Software that becomes personal is much harder to replace than software that merely performs a function.

The Apps that Require Trust

Another app I built is AI Kiddo First Words.

I originally built it for my one and a half year old son. I’m Romanian, his mother is Vietnamese and we speak English with each other, so he’s growing up in a trilingual household.

The app is very simple: he sees familiar objects and can hear their names in Romanian, Vietnamese and English.

Could somebody vibe code something similar? Absolutely.

Would I give some random vibe-coded app access to my young child without knowing what it does? Absolutely not.

The closer software gets to sensitive parts of our lives — our children, health, money, identity, private data — the more trust matters.

The App Is Not the Code

For a long time, building software was expensive. AI is rapidly making that part cheaper.

That’s a really big change, but an app isn’t just its source code.

It’s the idea, the decisions, the accumulated experience, the users, the data, the trust and the strange little details that make somebody open it again tomorrow.

As the cost of producing code approaches zero, those things don’t become less important. They become more important.

So, Is the App-pocalypse Coming?

Maybe.

Just not in the way the doomers think.

A lot of mediocre software is going to die.

A lot of simple SaaS functionality will become a prompt.

Some businesses that existed because software was difficult to build will disappear.

But I believe something much bigger will grow in their place.

WordPress didn’t kill the web. It made creating for the web accessible to millions more people.

Vibe coding may end up doing exactly the same thing to software.

And that doesn’t look like the death of apps to me.

It looks like the beginning of a much stranger app ecosystem.

I started with Claude, got into the Max subscription pretty fast, and I was mesmerized. For a while, it was really great. But then the Mythos / Fable circle ensued and I lost trust.

When fear mongering started, I also started to look elsewhere, so I ran a few experiments, trying to see if I can find a reliable replacement for Claude.

In the end, I switched to Grok – since version 4.5, mind you, before it was even cool. I still kept minimal subscriptions to Codex and Cursor. I also maintain what I call “a constant attention budget” aimed at free models. I have this hate for getting caught unprepared, so I go over my way to be prepared. Sometimes I overdo it, but that’s me. So I sometimes route work to free models, and I am experimenting at least once a week with local AI.

If you want to watch this as a video there: you go:

https://youtu.be/MdeyuHINFjM

What Are My Work Surfaces Now

I maintain 13 apps in the App Store (12 built in the last 6 months). I aim at releasing at least 1 more app every month. I also maintain this 20 years old blog (which still brings in decent traffic), a content site, and 2 SaaS.

On top of coding, there’s a lot of maintenance, content production and marketing.

I normally split work like this:

• Grok Bot for automations (mobile and web analytics, mobile app releases, new apps brainstorming and building MVPs, general admin support).
• Grok Build for hardcore coding (yes, I still do a lot of this). Difficult rewrites, major new features, bottom to top SaaS building.
• Grok web chat for menial, short questions. Sometimes I just want a quick check on a feature, or just on some trivia Cursor for some legacy agents (most of them are migrated to Grok Bot).
• The quality of the output is above median, always. There are times when it’s mind blowing, but even when it’s “meh”, it’s just good enough, and sometimes that’s all I need.

How Do I Feel? What Is My Role Now?

And with that we get to the core of the article.

I feel like a small business owner. I know how it feels to be a small business owner, because I’ve already been there. I started my first company when the Internet was just a “fading moment” and I built it for 9 years, until I made a successful exit. At the top, I had 25 employees and 20+ vertical portals, 2 of them being market leaders.

I have weird deja vu feelings. It all looks like when I started my company.

I am not the indie dev that started this journey in February this year, and I’m not saying this with an easy heart. I thought I can make it just by being an indie dev. Back then I thought we need to up our game 100x to be successful (5x just to stay relevant). I got that right, it really needs 100x more work.

What I didn’t get right is the type of work and my role there. I thought if I just amplify my activity with AI 100 times, that’s it. Well, it doesn’t work that way.

The whole AI thing is like a small army of employees that need constant steering, clear objectives and constant verification. It’s not just building a feature. It’s really about managing an entire company. You get stuff done for you, but you still have to decide what’s done, what’s the direction, how to reach the goal and who does what.

It’s literally about building a team, not a portfolio of apps.

And that team needs to be responsive, available and reliable. I don’t need Mythos drama. I don’t need OpenAI’s civilizations of agents. I just want to get to my 100x amplification level.

So, here I am, back to where I started 25 years ago. A new startup, but my partner is now an AI model.

We have achieved AGI!

New model is launched this week, and AI Twitter is like:

We have achieved AGI! Again!

This is getting tiring. And, in general, makes everybody trust the whole process less, not more.

What is this AGI anyway?

• Booking tennis court tickets?
• One shotting GTA 6?
• Talking to some entity named after a crab on your Telegram?

We already solved these problems. We’re just solving them again, faster, and at lower costs (allegedly, I’m not sure we’re actually paying less if all that compute and data is accounted for).

How we can call this AGI? Is there anything that this AGI solved that we couldn’t before? Like in our real, tangible, day by day life?

Oh, I hear you, over there, in the back. It solved a few very difficult math problems. Yes, I get that.

But it’s all theoretical for now. Like solving the mathematical processes for terraforming a 100 light years distant planet. We know how to terraform that! Great! And how we get there? What good is it for humanity that we solved a thing we cannot even touch?

How about solving the problems that we didn’t solve before?

How about solving the Moon settlements in a way that doesn’t makes us crippled by low gravity exposure?

Or even better, how about solving Mars travel any time we want, not only every 2 years? And actually making it there in good health, without our bodies fried by cosmic exposure.

My AGI is:

• Booking next solar system tickets
• One shotting a cancer vaccine that is guaranteed to work for my genetic blueprint.
• Extending life to hundreds of years and becoming a truly multiplanetary species

That is the point from where I can even think to name what we train on huge data centers, AGI.

Don’t get me wrong: I like drawing pelicans riding bicycles. I think this is fun and I understand this is a nice benchmark. So? When was the last time a pelican riding a bicycle did something relevant for you? And if you’d tell me you actually saw a pelican riding a bicycle in your neighborhood, I’d ask you politely to share what you smoke, because it sounds really strong.

I can almost see now, in slow motion, the fingers of keyboard warriors approaching the tastes, all typing the same thing at once: DECEL!

I’m sorry, but no. I’m not a decel.

Actually, I think I’m more acc than 99% of those who are reading this.

But I happen to think that acceleration for the sake of acceleration, without a clear and useful direction, is suicidal.

It’s just statistics: if you keep accelerating, not giving a fuck to where you’re going, you’re bound to hit a wall, rather sooner than later.

And you’ll die.

You don’t need to know Swift, Objective-C, or how the inner workings of an iOS app are laid out. You need the right AI agent and a structured workflow. Then you can go from an idea to a working app — and then maintain, update, and submit it to the App Store – using just plain English.

https://youtu.be/A3R6mBUnPOM

In the video above, I describe my Vibe Coding Toolkit for iOS, built around the two stages of a successful app:

• INCEPTION — how you create the app, what technical frameworks are used, design systems, monetization, everything. This stage is covered by my iOS Genesis Mega Prompt, which turns an idea into a properly structured iOS app. The prompt is a 24-section template I created incrementally while building my 13 iOS apps that are now live in the App Store.

• MAINTENANCE — this stage is overlooked by 99% of vibe coders, who are not prepared for the workload. I solve this using an AI-controlled Release Agent that talks directly to the App Store Connect API to fetch metadata, update keywords, attach builds, upload screenshots, check submission status, and submit releases for review.

The 2 tools above are just artifacts that need to be made available to your agent of choice, Claude, Codex, Grok, Cursor. You don’t use them directly, just install and configure. You work in plain English while the agent handles the implementation.

I also show how to create the App Store Connect API key correctly, why you need the App Manager or Admin role, and how the dry-run workflow prevents an AI agent from changing your live App Store data without your approval.

Requirements:

• A Mac with Xcode
• An Apple Developer account
• An AI coding agent
• An app idea

Nothing else.

If you’re already vibe coding an app, tell me what you’re building in the comments. I’d love to check it out.

So I did what every AI obsessed person does these days: started to dig into config files, squeezing every ounce of juice from everywhere I can. It turned out that Grok Build talks to anything that speaks an OpenAI-compatible chat API. It can be a model on your machine, or a free model behind OpenRouter. You use the same interface and you flip models with /model and keep working.

The whole customization is in:

~/.grok/config.toml

Below is my actual setup. There are two different options, you can pick just one, or keep both.

Option 1: Local models

For this you need something serving the model on localhost. llama.cpp, LM Studio, Ollama — whatever you already like, as long as it exposes /v1/chat/completions. I configured my server to listen on port 8080, but you can choose whatever you want, it’s local anyway.

Then you tell Grok Build about it in the config.toml file:

[model.gemma-4-12b-local] 
model = "gemma-4-12b-it-qat-q4_0" 
base_url = "http://127.0.0.1:8080/v1" 
name = "Gemma 4 12B QAT Q4_0 (local)" 
api_backend = "chat_completions" 
context_window = 16384

[model.qwen-3-8-27b-local] 
model = "Qwen3.8-27B-UD-IQ2_S" 
base_url = "http://127.0.0.1:8080/v1" 
name = "Qwen 3.8 27b QT 2 (local)" 
api_backend = "chat_completions" 
context_window = 16384 

On my M1 16GB MacBook Pro I can run heavily quantized models in the Gemma / Qwen layer, nothing above that. Performance isn’t great, but it’s local. A few notes that can save you some time:

• model must match the id your local server expects, not the actual marketing name.
• base_url ends at /v1. Grok Build appends the rest.
• context_window should be kept minimal if you’re low on RAM (like I am). If you aim for 128k and the quantized model only holds 16k, you get compaction at nearly every prompt and long sessions are completely amnesic.

No API key needed for localhost. Start the server, which loads the weights, restart Grok Build, then in the new session:

/model gemma-4-12b-local

or you can start grok directly with the model as an argument:

grok -m gemma-4-12b-local

And that’s the whole local option. It’s offline, you don’t pay anything, and it’s private by default. Like I said, quality depends on your hardware, specifically RAM, and how aggressively you quantized. As a rule of thumb, meaningful work can be done if you have over 32GB of RAM, 16GB, like I do now, is mainly for experiments.

Option 2: OpenRouter free models

Local is really great, but most of the time you want a bigger model than your machine can hold. OpenRouter has a free tier for a bunch of open models. We will use the same harness, but with a different endpoint.

You will need an OpenRouter API key for this. Generate one in your dashboard, then add it to your environment:

export OPENROUTER_API_KEY="sk-or-..."

Then define the provider once, so you don’t repeat yourself for every model:

[model_providers.openrouter] 
base_url = "https://openrouter.ai/api/v1" 
env_key = "OPENROUTER_API_KEY" 
api_backend = "chat_completions"

[model_providers.openrouter.extra_headers] 
HTTP-Referer = "https://x.ai" 
X-Title = "Grok Build" 

Then add the free models you care about. Here’s my non-exhaustive list:

[model.glm-5-2-free] 
model = "z-ai/glm-5.2:free" 
name = "GLM 5.2 (OpenRouter free)" 
model_provider = "openrouter" 
base_url = "https://openrouter.ai/api/v1" 
env_key = "OPENROUTER_API_KEY" 
api_backend = "chat_completions" 
context_window = 256000

[model.openrouter-free] 
model = "openrouter/free" 
name = "OpenRouter free router" 
description = "Routes to whatever free OpenRouter model is available" 
model_provider = "openrouter" 
base_url = "https://openrouter.ai/api/v1" 
env_key = "OPENROUTER_API_KEY" 
api_backend = "chat_completions" 
context_window = 200000

[model.gemma-4-31b-free] 
model = "google/gemma-4-31b-it:free" 
name = "Gemma 4 31B (OpenRouter free)" 
model_provider = "openrouter" 
base_url = "https://openrouter.ai/api/v1" 
env_key = "OPENROUTER_API_KEY" 
api_backend = "chat_completions" 
context_window = 262144

The :free suffix is very important. Without it you hit the paid route. openrouter/free is also an interesting option — it picks whatever free model is available that day. I find it really cool for experiments. But for real work I pin a specific one, usually GLM 5.2 free or Gemma 4 31B free, so behavior stays somewhat consistent.

In the Grok Build harness you switch the same way:

/model glm-5-2-free

And you can also check what Grok Build can see:

grok models

How I Actually Use This

Almost 90% of my work sessions are on a paid Grok model, I maximize the full harness and its tools. I switch to local for private or offline sessions. And I choose OpenRouter free when I want a bigger open model without drawing from my Grok usage. Sometimes I go for models like Nemotron or DeepSeek Flash. I didn’t include the configs for those in this article, I just leave this as a little bit of homework for you.

The important part is the config file. Once ~/.grok/config.toml knows about a model, the rest of Grok Build treats it like any other: tools, sessions, /model, Ctrl+M picker. You’re never starting a second app onto your workflow. You’re pointing the same app at a different brain.

If something fails to connect, curl the endpoint first. For local:

curl -s http://127.0.0.1:8080/v1/models

For OpenRouter:

curl -s https://openrouter.ai/api/v1/models -H "Authorization: Bearer $OPENROUTER_API_KEY"

If curl is happy and Grok Build isn’t, it’s almost always a typo in model, base_url, or env_key.

That’s my entire setup: one harness, two free paths and endless choices. All you have to do is edit the toml, restart or switch with /model, and keep building.

But You Just Paid the Invoice

Yes, I hear you. You just paid a Claude / Codex / Grok invoice and it was probably in the hundreds or thousands of dollars. I’m not saying those tokens you just paid don’t exist. I’m saying they are not based on a real market mechanism. They’re an expectation, an aspiration, they’re what neolabs hope to receive. How is that even possible?

I tried to explains everything in the video below.

https://youtu.be/U7LRzj37pGw

Here’s a short summary, so you know what to expect.

Why the Token Price Even Exists

A SOTA model is made of 2 things: data and compute. Both are extremely expensive. Neolabs took a lot of money from investors to train those models, and they came up with something plausible, and lately, something that can even produce production level code.

But this is horrendously expensive. Now, as a normal user, you wouldn’t pay the real price, simply because it’s prohibitive and it’s still more effective to hire a developer. So neolabs started to sell subscriptions, which have a number of tokens included. It’s like tasting the product. If you want more, you get the price per token.

The best way to understand this is to think at a Ferrari: it’s an extremely expensive car, you cannot afford it probably. So you do not buy the car. You rent ten hours. Renting is the price by the token. The gap between those two prices is unusually large because in the case of AI the product is new and demand is still low.

We Have 3 Layers of Price

1. Real cost — billions. Nobody can afford this.

2. Lab token price — close to what they need to look solvent in front of investors, not necessarily what the work is really worth.

3. Open source / local — often 10× cheaper, 95–98% good enough for coding, analysis, and admin.

The local, private AI is starting to make sense financially, too. Six months ago a local DeepSeek-class box was $25–50k. Now ~$10k (Mac Studio or two DGX Sparks) gets you Qwen / GLM territory near last-gen Opus / GPT.

Something Changed in the Last 6 Months

Now we know what are the real use cases for LLMs: coding, data work, email/meeting cleanup. These are impressive but in and by themselves do not automatically support the rates neolabs are asking for frontier models.

The reality will probably kick in in the next 3–6 months:

• Either neoabs cut prices to defend their market share, or

• Open-source (China + US) takes over the market entirely

The IPO is the key moment and we are a couple of months away from this.