I suppose I should have said they just didn't go up faster than the capabilities of local models are improving. I suspect local model/hardware capability will scale up faster than most people's needs when it comes to coding. That's likley why Sam Altman has naughty designs on your RAM.

Easy: it's an open secret (the quiet part) that the rich fucks want us to rent everything and us own nothing. Real estate was the first to go unaffordable without taking up debt. Then came cars. Then phones. And now it's computers. Hell I've seen kitchen appliances for rent.

And now this mf'er (or to be more precise, alleged sf'er [1]) goes on the record to say it's bad if we the people have RAM.

Fuck him, fuck everything he stands for.

[1] https://www.theguardian.com/technology/2026/oct/20/judge-dis...

He literally said we'll own nothing and be happy

> Altman was simply making an accurate observation about DRAM

no, he was lying by omission

"it's quite terrible" only if you ignore all the problems with plans they promote and measure it only in metrics Altman wants to measure, as they support his plans

For start, Altman would charge as much as possible to optimize profits, so very significant part of efficiency increase would become profits of "Open"AI.

As another obvious problem: handing so much power to a specific company has own costs.

There are so many problems here with this specific part - starting from their power dictating how can you use it, access to your data. And that part is getting worse for anyone not planning to obey all decisions coming from USA. We have already seen export controls being invoked.

But wider, if you think that outsourcing thinking to a specific SaaS has no costs, beyond current subscription costs, then I have several thousands of bridges for sale.

> Altman was simply making an accurate observation about DRAM

Which might be true, I'm willing to accept that, but it does not change the fact his message was incredibly tone deaf.

Cost of living in general is through the roof for years now, many people haven't had the financial ability to meaningfully upgrade their computers for just about the same timeframe - first Bitcoin drove CPU prices through the roof, then GPU prices, once that died down due to ASICs there were a few fads that "mined" RAM, HDD and SSD, and in parallel to the latter Covid hit, disrupting supply chains. After Covid was somewhat over, the Russians invaded Ukraine, then we got the various MENA conflicts after Oct 7th, and now the Iran war is wrecking everything - and ever since AI entered the picture somewhat three years ago, first GPUs and now everything else has exploded in price. Entry level smartphones have all but disappeared. And don't forget our existing computers got less and less useful because first Microsoft pushed the garbage called Windows 11 onto everyone it could and second, everyone and their dog went for Electron resource hog apps.

For Altman to now say "your unused RAM could be of much better use in our servers" is like a giant fat fucking middle finger, telling us to sacrifice even more of our needs just for the opportunity of him and his fellow rich bastard friends to make more money, all while he and his fellow rich bastard friends are executing the setup of a financial crisis that will make 2007 look fucking tame.

> Thiel's comment is also pro-individual-ownership - in context he was talking about the danger that in a mass democracy the people as a whole would vote to have the government restrict the freedom and confiscate the property of successful people (particularly prescient in light of the recent California attempt at a billionaire wealth tax).

Oh for fucks sake. Taxes aren't theft, they provide for the environment that makes these rich fucks able to earn money in the first place. Thiel is worth 38 billion dollars. Even if you'd tax the guy 50% of his wealth, he'd still have more than one single human and their descendants can ever feasibly gamble away.

> RAM being expensive is better than RAM being rationed by a democratically-elected government so no one person has too much, as judged by the voting masses.

At least in a rationed system that allocates supply fairly, ordinary people wouldn't have to run with barely working hardware because they can't afford to buy something new and modern for once as all the new stuff is hoarded by the rich like a LotR dragon hoards his gold pile.

And as evidenced by this week's elections - the people are fed up beyond belief. Either we the people get some relief, the sooner the better, or the situation may indeed devolve into open riots.

Successful people are not successful without keeping unsuccessful people from success; inflation since Millennials were born is almost 300% and taxes have been slashed; takes 800k/yr now to have the buying power of $200k in the 1980s

Thiel has benefited from wealth being wielded by rich media owners to convince the masses decades long trends in deflation of buying power through inflation of costs are good for them

With such a system giving him a boost he was successful before Millennials and GenZ were adults or even born

Altman came along during ZIRP; being successful when the government is intentionally printing money is not really success

You're changing the goalposts.

The above comment said:

> need to buy tokens from a handfull of tech companies to run their businesses or make their products

That's clearly indicating necessity.

That would indeed be concerning if it was the case, but it's not.

So now the case is just "you can pay more money to do things faster".

And guess what? That's been the case for centuries if not millennia. Nothing special or concerning at all.

And so your analogy is misleading. You're trying to imply that only a tiny number (2-3?) of companies make the tools, and nobody else does. You either pay those companies, or you don't get them.

That's just false. There are hundreds of companies that will sell you tokens - just not for frontier models. The correct analogy is how Samsung, Google, and Apple make the best phones in the world, so you can buy from one of them - or you can buy a still-good but not bleeding-edge phone from another vendor. And everyone is fine with that.

There are already 80 providers on Openrouter.

> Let's say I use the $200/month Claude (I don't, I use a cheaper plan, but stay with me). If I switch to a Opus 4.5 equivalent local LLM, and it makes even a single production issue that 5.5 wouldn't, that mistake will cost thousands of dollars.

You are assuming that Opus would always be superior; the cloud AI providers can be very variable. They can be very useful for months, but during certain times their quality can drop off a cliff. People online speculate that the cloud providers drop quality during this time when they are training a new model or the service is over-subscribed. You do not have that issue with a local model.

That issue of quality of service is enough many businesses may prefer a locally run model because it will be more consistent.

It's way better than Opus 4.5. See my stress test elsewhere in this thread (C -> microcode compiler with optimizations written in OCaml, generates microcode + Verilog output) - it's doing better than Opus 4.6/4.8 were when I was using them to code the original C version of this compiler early in the year. It's come up with optimizations that Claude didn't come up with back then.

> Let's say I use the $200/month Claude (I don't, I use a cheaper plan, but stay with me). If I switch to a Opus 4.5 equivalent local LLM, and it makes even a single production issue that 5.5 wouldn't, that mistake will cost thousands of dollars.

There are a few points I'd like to make here.

First, the frontier is jagged. There are errors that Qwen3.8 Flash Next make that Opus 5.5 doesn't make, but the reverese is also true: Opus 5.5 makes errors that Qwen3.8 Flash Next doesn't make. The latter will likely be fewer, but they won't be zero. Outside of really large differences in capabilities, there is no total ordering among models, only a partial one.

As an aside, do you always run Opus 5.5 at max reasoning in order to minimize errors, too? I suggest most people don't, because they have their own intuition for good enough vs. cost.

Second, Opus 5.5's strength are autonomous tasks. For interactive, HITL work, it's not a particularly great choice. This includes its preferring complex Bash commands over tool use and inscrutable Python scripts, but also often not even explaining what it does. It is not a great choice to use as a virtual pair programmer, because following along what it does and maintaining a mental model is harder than with some other models (though probably because of benchmarks that prioritize autonomous work, these and related problems have infected other models, too). You can address that to an extent with CLAUDE.md instructions, but even that has imperfect results.

Finally, if you rely on a model not to make mistakes in order to ensure correctness, your software development process is fundamentally broken. You need to assume that any model will make at least some errors and need a development process that accounts for that. The problem here is not necessarily which model creates fewer errors, but which model creates code where errors are easier to discover. Ironically, more powerful models may create more complex code, making that harder.

You can see an analogous effect with reasoning effort in FrontierBench 2.0 [1]:

"FrontierCode is one of the few coding benchmarks where writing additional (correct) code doesn’t necessarily raise a model’s score. This leads to an interesting phenomenon: models can score lower at higher reasoning effort. Because this non-monotonicity often matches user sentiment but is hard to see in other evals, we consider it a useful feature of the benchmark."

A example:

"This task comes from PostHog’s open-source Android SDK, which apps use to record analytics events. When the device is offline, the SDK writes events to disk and sends them the next time the app starts. The task is to fix a startup bug in which two modules send data at the same time: the live queue sends new events while a legacy integration, PostHogSendCachedEventsIntegration.kt, sends the cached ones. The two race, and events reach the server out of order.

"At low effort, GPT-6 Astra moves cache loading into PostHogQueue.kt, removes the sending logic from the legacy integration, and leaves the SDK’s public API untouched, which produces a passing solution.

"At max effort, the model often deletes PostHogSendCachedEventsIntegration.kt outright and spreads its responsibilities across other legacy files. This also fixes the race and passes most of the hidden behavior tests. But the deleted class is part of the SDK’s public posthog.api surface, so removing it introduces an unnecessary breaking change for every app that references it. Scope blockers, which deterministically check that the model hasn’t modified certain files, catch this change, and the agent fails the task."

[1] https://cognition.com/blog/frontier-code-2.0

> Let's say I use the $200/month Claude (I don't, I use a cheaper plan, but stay with me). If I switch to a Opus 4.5 equivalent local LLM, and it makes even a single production issue that 5.5 wouldn't, that mistake will cost thousands of dollars.

What are you talking about, you're fully dependent on an LLM (Opus or whatever) not making a mistake or else you lose thousands of dollars, in production? How is that okayed?

"It" makes a production issue? Are you not involved in this process?

Yea your math doesn't math.

Try it before you go super far into the world of this "must suck".

Most people aren't going full vibe code. If you stear these models, they are almost identical. Seriously. The major score changes in a lot of the absolute latest models are just models doing more things (often when they shouldn't). Having a slightly lower scoring model is actually better in some ways. I digress.

If your model can make a production mistake you are using it wrong. Sorry not sorry.

There are other benefits. Your data is private, it's not sold. Your privacy is kept, that's priceless. No one can degrade your workflows. Uptime is you are online whenever you are online not 3 9s. You also won't get refused asking basic security questions.

Your math doesn't math for a lot of people. It might for you, but I would encourage you to think a little more.

Not necessarily. If yor process accounts for "all models make mistakes", you are probably limiting how autonomous the model can be, and then there's not much tangible difference between models beyond that threshold.

In the competitive landscape, cost and not-getting-locked-down are also factors up for consideration.

Given the vast amounts of constant external investment money they need to keep operations, and how little moat (if any, besides influx of investor money) they have, I'd argue it's not that far fetched. Also, they are all american, so as a non-american, I also don't see it that unlikely to suddenly not being able to access these model-as-a-service services

If the planning-for-a-$2T-IPO company shuts down overnight, unexpectedly, you might want to do some actual doomsday prepping (like, canned food).

But there's just no way.

This is what I've been doing with qwen3.8-flash-next. I haven't fully let go of the reins yet but I do like having a junior who can implement my new features as I have designed them

I don't know and can't answer or predict that. But that's exactly what it could become (although probably not that extreme), where the agents doing much of the internal work are proprietary, conferring a research advantage.

So far, it does, because the products and services are the general intelligence produced by the research.

It's very hard to measure exactly how large it is, because there aren't good pre-existing metrics for it. You can measure in time (e.g., how far behind open weight models are from the best frontier models commercially available), but it's plausible that what seems like a relatively small time advantage (months) might mask a considerable difference in internal research sophistication. What we've seen repeatedly is simply that there does seem to exist a durable advantage in research productivity, at least for now.

I’m not convinced that being able to serve open models makes the closed labs business model non-viable. I think there is overlap but I also think these are distinct value propositions. I wouldn’t dismiss the ability for one organization to point lots of resources at a particular problem, for example.

I don’t have any stake in this and I hate the idea of concentrated wealth and power, wherever it is: government or private businesses. But would I bet against it? Probably not.

Source?

I'm using it in opencode through llama-swap.

Here's the gufo command:

gufo serve 1lm \ -m /mnt/LLMs/models/unsloth/Qwen3.8-Flash-Next-GGUF/UD-104_XS/Qwen3.8-Flash-Next-UD-1Q4_XS-80081-0f-00083.gguf \ --served-model-name Quen3.8-Flash-Next-UD-104_XS \ --host 127.8.8.1 --port 10083 \ -c 262144 -n 16384 -j 1 \ --prefill-chunk 8192 \ --speculative mtp \ --mtp-model /mnt/LLMs/models/unsloth/Qwen3.8-Flash-Next-GGUF/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf \ --cache-disk ~/.cache/gufo-fork \ --cache-disk-bytes 68719476736 \ --cache-disk-staging-bytes 8589934592 \ --cache-ran-bytes 4294967296 \ --log-progress

OP could be read either way, but the dev environment threat is not rocket science to manage: LLMs can only do what the harnesses their responses are embedded into explicitly enable them to do [1]. And once the setup is secured, it tends to stay secured without additional effort, unless one explicitly wants to alter its granted capabilities.

Auditing output by contrast is a continuous cost. On the third hand, it's one that most will want to pay anyway.

The "embed into shipped code so subtly humans can't spot it" vector is sci fi ish. Less plausible than old fashioned trusting-trust issues, and most folks have managed to sleep at night for the last 40ish years that spectre has haunted.

[1] I guess the model could return output that buffer overflows the harness and exceeds its intended ability, but that seems far-fetched too

>just read the damn code yourself!

It's basically impossible to do this. Claude produces so much excessive / verbose code and comments that reading it would take far longer than simply doing the implementation "by hand". It's kind of like, Claude can write the code in 1/2 a day. It can be reviewed by another LLM, unit tested by another for 1 day. Or I could write the code in probably 3-4 days. Reading it and validating / testing it myself though would easily take 6+ days.

Now if I were fully in control I wouldn't run code that wasn't truly reviewed at all, but in the situations where Claude is being used that's not my call. TBH a lot gets caught, and I have some automated scripts that find a lot of the more problematic stuff automatically, flag it, send it back and make note for the reviewer model as well.

I will also spot check areas where I think an issue could arise.