A Computer Lives Inside This AI Model — And It Has a Filesystem
There's a 4B parameter model out there that doesn't call an external computer to do arithmetic. It carries one inside its own weights.
It's called Qwenputer, built by Divyansh Agrawal, and it embeds a deterministic 32-bit RISC-V CPU directly into Qwen3.5–4B. The model can run C and MicroPython code during its own forward passes — no plugin, no sandbox, no tool server. The original Qwen weights stay untouched; the computer is added through extra layers and dimensions that were compiled, not trained.
How a Neural Network Becomes RAM
The trick is in Qwen3.5's Gated DeltaNet attention mechanism. Normally it maintains a state matrix for language modeling. Qwenputer reconfigures it into addressable memory with three changes:
- Set the gate to 1, so existing values don't fade
- Set write strength to 1, so new values completely replace old ones
- Use one-hot keys and queries, so each row acts as a single memory cell
Registers, program data, and the program counter all live inside that recurrent state. Fixed size, no KV cache growth. It's not a CPU that emerged during training — it's engineered from primitives already in the architecture.
The CPU Is Compiled, Not Learned
Eleven transformer layers sit before Qwen's original 32. None of their weights were learned through gradient descent. A compiler calculates them directly from a circuit description. Attention heads do lookups, feed-forward units handle arithmetic and logic, Gated DeltaNet heads hold memory.
Each CPU instruction produces trace tokens — ADDR for a memory row, VAL for the value, STEP to complete. The token stream is both model output and an execution log. Qwen accesses it through tool-call format it already understands, but nothing outside the model receives the request. The compiled layers read it, execute, and cause the model itself to generate the response.
The Part That Actually Matters: A Filesystem
Here's where it gets genuinely strange.
Qwenputer has an in-model filesystem. When the model saves a file, the compiled layers hash its name into one of 1,024 directory slots stored in Gated DeltaNet state. The text occupies other heads, eight tokens per row, chained together. Hash collisions are handled by checking subsequent slots.
The current implementation holds up to 512 files — roughly 53,000 tokens of text. And here's the key part: save the recurrent state at the end of one conversation, restore it later, and the files remain available.
This isn't a transcript pasted into the next prompt. It's structured, addressable storage manipulated by the model's internal machinery. The model writes to its own filesystem, and that filesystem persists across sessions.
Think about what that means for how we think about AI memory. Right now, "memory" in most systems is just context window management — stuff you cram into the prompt. Qwenputer shows a different path: the model has its own storage, it can write to it, and it can read from it later, in a different conversation, with no external database in between.
The Numbers
Author-reported benchmarks (greedy decoding, 40 problems per set):
| Benchmark | Qwenputer | Base Qwen3.5–4B | Qwen + Python tool |
|-----------|-----------|-----------------|-------------------|
| NUPA long-integer arithmetic | 100% | 48.6% | — |
| DeepMind div_big | 97.5% | 72.5% | 95% |
| DeepMind mul_big | 97.5% | 55% | 100% |
| DeepMind mul_div_multiple_longer | 100% | 90% | 97.5% |
The CPU passes RISC-V instruction tests, matches QEMU on tested programs, and completed 18 million free-running instructions without a single error. About 230,000 generated output positions were replayed against a reference machine with zero mismatches.
What It's Not
It's not faster than Python. It's not a replacement for your CPU. The checkpoint is 18.8 GB in BF16 (mostly zero padding), it needs a custom driver called RvChat, and execution runs at about 3,200 trace tokens per second on an L4. One instruction costs several tokens, so large calculations take seconds rather than milliseconds.
It's a research prototype. A very impressive one, but a prototype.
Why It Matters Anyway
Three ideas here are bigger than the benchmark numbers:
Weights can be compiled, not just trained. You can insert analytically constructed circuits with known, testable behavior alongside learned language behavior. That changes what a model checkpoint is.
Recurrent state can become exact, programmable memory. Not approximate. Not "the model remembers this." Actual addressable storage that the model's internal machinery manipulates. The filesystem is the proof of concept for something much larger.
The boundary between model and runtime dissolves. If computation, memory, and language generation share the same internal state, where does the model end and the computer begin? That question gets more interesting every time someone answers it with working code.
The next time an AI produces a tool response, Qwenputer leaves you with a question that's harder to shake: what if the tool, the runtime, and the computer were all inside the weights? And what if it could remember what it did last time — not because someone pasted a transcript, but because it wrote a file to its own disk?
Source: Mehul Gupta, "What is Qwenputer? A Working RISC-V CPU Inside Qwen3.5", Data Science in Your Pocket, October 2026.