Daily AI Fresh News · October 15 Midday Edition: Large-Model Pretraining Running on NPUs

Lots of new movement in AI today — chips, voice, models, one after another.

Here's what we're mainly covering today: first, AI designing chips. Second, Grok Voice 3.0. Third, oh-my-agent's rapid-fire releases. Fourth, Gemini 4 Argon. And fifth, a tool for tracking what AI bigwigs say.

For the deep dive, two things: one, running large-model pretraining on NPUs. And two, how to deal with 429s on free APIs.

Yeah, we've got plenty of material today.

Let's start with the first one. The chip space has been absolutely cutthroat lately.

Just saw something on TechCrunch — a company called Ricursive Intelligence is betting on AI-designed chips.

Their idea is to let AI design chips itself, learn from each iteration, and make the next version better.

I think this direction is inevitable. The chip design process is way too slow — human tuning just can't keep up with compute demand.

The point isn't designing better than humans. The point is iteration speed. A machine runs a thousand versions a day; a human polishes one version a year.

But is the chip it designs actually reliable? A tape-out costs a fortune.

That's why they emphasize the closed loop — learn one round, improve one round. Only after simulation validation passes do you tape out. So the risk is manageable.

Second item, Grok Voice 3.0. Someone on dev.to flagged that on October 14 it quietly took over the grok-voice-latest alias.

The author's message was just one line: if you're building voice agents, pin your model version right now.

This trap is so classic. "Latest" is a Schrödinger's version — if you don't pin it, the voice your users hear could be different today and tomorrow.

And with voice, the moment the timbre changes, users notice immediately.

Right. With text models, you might not notice a version change. With voice, your ears catch it in a second.

Then there's this one — the oh-my-agent CLI project shipped five major versions in seven days, going straight from 15.10.0 to 20.0.0.

That release cadence is kind of insane. And I hear most of them were intentional breaking changes — just deleting old paths, no compatibility layer.

Yeah, and oma-security replaced the old deepsec, consolidating into one global home.

I can't fully get behind that approach. Small teams can get away with it because they've got no baggage — but anyone using it has to chase the code changes.

Fourth item — Google's Gemini 4 Argon is now globally available, with a one-million-token context window.

Officially it's positioned for long-horizon sustained reasoning — software development, enterprise knowledge tasks, and cybersecurity.

A million tokens isn't fresh news anymore. What's fresh is that they dare to claim long-horizon sustained reasoning.

A long context doesn't mean it can keep thinking. It forgets things in the middle, it drifts off track — that's the real barrier.

So the real competition is stability on long tasks, not who has the bigger window.

Exactly. That number on the spec sheet is the easiest thing to copy. Long-range consistency is the real moat.

Last one's pretty interesting — someone on Hacker News built a tool that specifically tracks what AI bigwigs have said, to see how their views change.

I love this. It's basically a flip-flop ledger for the whole industry.

Think about it — six months ago someone said a direction was a dead end, and now they might be diving in themselves.

So the value of this isn't gossip — it's letting you see clearly whether a judgment is being driven by evidence or by the prevailing wind.

Alright, that's it for the news. Next, we dive into two topics.

First — VIDRAFT pretrained a language model from scratch on NPUs, without touching a GPU the whole time.

Personally, I think this is today's most discussion-worthy item. It goes straight at the industry's toughest assumption.

Everyone knows pretraining equals GPU clusters, equals burning cards, burning power, burning money. Now someone says you can do it on NPUs.

Hold on — aren't NPUs those little units in phones and PCs specialized for inference? Can they handle pretraining?

That's the most counterintuitive part. NPUs are designed for low power, fixed-point inference — not large-scale floating-point training.

So how did they pull it off? Just software optimization?

The source material doesn't go into detail, but getting a full pretraining run to finish means they cracked the inter-chip interconnect and scheduling.

What's the significance? Saving money?

Not just money. It's about supply. Only a handful of companies globally supply GPUs. If you can use NPUs, you've basically opened up an entire new supply chain.

And NPUs are everywhere on the edge — phones, cars, edge boxes. Maybe down the road, pretraining and inference really won't live in the same hardware world.

But I'm a bit skeptical — could this just be a one-off? A small-scale, small-model kind of demo?

That skepticism is totally reasonable, and I half-agree. It definitely won't replace GPUs tomorrow, but it's cracked open a seam in the industry's assumptions.

On Reddit, probably half the people are shouting revolution and the other half are asking how many total parameters were trained. If that info isn't transparent, the conclusion has to be discounted.

So to sum up — NPU pretraining may not immediately upend GPUs, but it proves there's more than one path for pretraining hardware.

Right, exactly. Breaking a single dependency — that in itself is big news.

Second topic is way more down-to-earth. 429s on free LLM APIs — you've definitely hit them.

Way too familiar. You're using your free quota, and suddenly a 429 slaps you in the face — rate limit exceeded.

There's a hands-on guide on dev.to about this. The author says most tutorials just tell you to add a retry loop — way too lazy.

Yeah, plain retrying is the dumbest approach. The harder you retry, the harder you get throttled, and eventually the whole task collapses.

So what should you do?

Do it in layers. Layer one: exponential backoff with jitter. Don't all retry in perfect lockstep — that's not backoff, that's a siege.

Layer two: multi-provider routing. If one says 429, switch to the next. Don't hang yourself on one tree.

Isn't this just like the early days of web scraping — rate limiting, proxy pools, queueing.

Exactly the same. It's just porting anti-scraping experience over to LLM calls.

I think the most fundamental thing is: don't treat free as production. Free quota is for you to try, not for you to run on.

That's right. A programmer on HN also said — 429s aren't scary. What's scary is your system having only one provider and no fallback path.

So the takeaway is: 429 isn't an error, it's the norm. Treat it as part of your system design, not as exception handling.

Yeah, that line belongs on a poster.

Alright, that's about it for today. NPU pretraining and the 429 playbook — both are worth chewing on.

See you tonight. Bye-bye.