Rmm Netwolf

[Rmm Netwolf @SMCNetwolf]

@leoxbtt Good idea

[Rmm Netwolf @SMCNetwolf]

What can go wrong?

[Rmm Netwolf @SMCNetwolf]

How Claude Code Actually Works Internally — The Architecture Deep Dive https://t.co/Vp0qDvzxnX via @YouTube

[Ali Zaid @heyalizaid]

@swyx @ClementDelangue

[swyx @swyx]

lmao @ClementDelangue doing the 🇳🇴

[Akshay 🚀 @akshay_pachaar]

CPU vs GPU vs TPU vs NPU vs LPU, explained visually:

5 hardware architectures power AI today.

Each one makes a fundamentally different tradeoff between flexibility, parallelism, and memory access.

> CPU

It is built for general-purpose computing. A few powerful cores handle complex logic, branching, and system-level tasks.

It has deep cache hierarchies and off-chip main memory (DRAM). It's great for operating systems, databases, and decision-heavy code, but not that great for repetitive math like matrix multiplications.

> GPU

Instead of a few powerful cores, GPUs spread work across thousands of smaller cores that all execute the same instruction on different data.

This is why GPUs dominate AI training. The parallelism maps directly to the kind of math neural networks need.

> TPU

They go one step further with specialization.

The core compute unit is a grid of multiply-accumulate (MAC) units where data flows through in a wave pattern.

Weights enter from one side, activations from the other, and partial results propagate without going back to memory each time.

The entire execution is compiler-controlled, not hardware-scheduled. Google designed TPUs specifically for neural network workloads.

> NPU

This is an edge-optimized variant.

The architecture is built around a Neural Compute Engine packed with MAC arrays and on-chip SRAM, but instead of high-bandwidth memory (HBM), NPUs use low-power system memory.

The design goal is to run inference at single-digit watt power budgets, like smartphones, wearables, and IoT devices.

Apple Neural Engine and Intel's NPU follow this pattern.

> LPU (Language Processing Unit)

This is the newest entrant, by Groq.

The architecture removes off-chip memory from the critical path entirely. All weight storage lives in on-chip SRAM.

Execution is fully deterministic and compiler-scheduled, which means zero cache misses and zero runtime scheduling overhead.

The tradeoff is that it provides limited memory per chip, which means you need hundreds of chips linked together to serve a single large model. But the latency advantage is real.

AI compute has evolved from general-purpose flexibility (CPU) to extreme specialization (LPU). Each step trades some level of generality for efficiency.

The visual below maps the internal architecture of all five side by side.

Notice the thread connecting all five. Every generation exists to move data less, because the math was never the hard part. Feeding the math units fast enough is.

The same battle plays out one layer up in software. During LLM inference, a single GPU produces terabytes of KV cache per day, and nearly all of it gets thrown away and recomputed, which is a big reason agent workloads cost what they do.

I wrote a full breakdown of how a disaggregated caching layer fixes this, with up to 14x faster time-to-first-token. The article is quoted below.

You should also check the @lmcache GitHub repo: https://t.co/TXlaLLu04a

(don't forget to star 🌟)

👉 Over to you: Which of these 5 have you actually worked with or deployed on?

[Rmm Netwolf @SMCNetwolf]

@RubenTorney @googledevs I did! It's excellent!

[Rmm Netwolf @SMCNetwolf]

@googledevs I'm using Gemma 4 multimodal locally and it is already amazing. Can't even imagine how powerful this one will be!

[Rmm Netwolf @SMCNetwolf]

@namcios They surely should ask for permission to download something that big!

[Rmm Netwolf @SMCNetwolf]

@MarioNawfal Amazing!

[Rmm Netwolf @SMCNetwolf]

Was Google Antigravity hacked? It was unauthorizedly reading .env files yesterday!

[Rmm Netwolf @SMCNetwolf]

@akshay_pachaar Bookmark this one

[Rmm Netwolf @SMCNetwolf]

@RomeuMeirelles Wow!

[Google for Developers @googledevs]

Gemini CLI’s new Subagents feature is a game-changer for terminal productivity. It turns your primary agent into a strategic manager that delegates sub-tasks to specialized experts.

👉 Subagents keep the main window fast by handling high-volume tool calls in isolation
👉 Run specialized agents for code exploration and analysis simultaneously
👉 Use .md files to create agents tailored to your specific project standards

Scale your dev workflow without the clutter. 🧠💻

[Google Antigravity @antigravity]

Mission Report is out now! Catch up on everything new in Antigravity + Q&A!

[Rmm Netwolf @SMCNetwolf]

https://t.co/uwaNm8ua91

[Andrej Karpathy @karpathy]

I had the same thought so I've been playing with it in nanochat. E.g. here's 8 agents (4 claude, 4 codex), with 1 GPU each running nanochat experiments (trying to delete logit softcap without regression). The TLDR is that it doesn't work and it's a mess... but it's still very pretty to look at :)

I tried a few setups: 8 independent solo researchers, 1 chief scientist giving work to 8 junior researchers, etc. Each research program is a git branch, each scientist forks it into a feature branch, git worktrees for isolation, simple files for comms, skip Docker/VMs for simplicity atm (I find that instructions are enough to prevent interference). Research org runs in tmux window grids of interactive sessions (like Teams) so that it's pretty to look at, see their individual work, and "take over" if needed, i.e. no -p.

But ok the reason it doesn't work so far is that the agents' ideas are just pretty bad out of the box, even at highest intelligence. They don't think carefully though experiment design, they run a bit non-sensical variations, they don't create strong baselines and ablate things properly, they don't carefully control for runtime or flops. (just as an example, an agent yesterday "discovered" that increasing the hidden size of the network improves the validation loss, which is a totally spurious result given that a bigger network will have a lower validation loss in the infinite data regime, but then it also trains for a lot longer, it's not clear why I had to come in to point that out). They are very good at implementing any given well-scoped and described idea but they don't creatively generate them.

But the goal is that you are now programming an organization (e.g. a "research org") and its individual agents, so the "source code" is the collection of prompts, skills, tools, etc. and processes that make it up. E.g. a daily standup in the morning is now part of the "org code". And optimizing nanochat pretraining is just one of the many tasks (almost like an eval). Then - given an arbitrary task, how quickly does your research org generate progress on it?

[Rmm Netwolf @SMCNetwolf]

@_mohansolo I personally experienced an import degradation in Antigravity service quality recently. I assumed it was related to the switch into the new model, but maybe the explanation is more complicated than that.

[Rmm Netwolf @SMCNetwolf]

What's the real cost of IA? When it turns equal to human cost, the adoption will stop, because human is better.

[Rmm Netwolf @SMCNetwolf]

https://t.co/ORwXvkSZFE