iammatthias — #side-projects

Intern

Fri, 19 Jun 2026 02:10:06 GMT

Ah, the Autonomous Intern. A glorious little housing meant to sit on your desk with its LEDs flashing, letting you know it's hard at work on whatever you threw at the agent it's running.

Out of the box, the Intern is a Raspberry Pi 5 with 4 GB of RAM and a 64 GB SD card. It ships with a factory install (the docs imply Debian Bookworm), and when you plug it in, it boots into access point mode. You connect to its wifi network (Intern-XXXX) and set it up from there.

You can also pop the case open by removing four screws, minding the wires for the LED array. With some tweezers you can pop the SD card and flash it with whatever you want. It's a Pi! Have some fun with it.

Well, I had some fun with it. I reworked the setup script Autonomous provides with some defaults that I preferred:

Debian Trixie instead of Bookworm
Caddy instead of nginx
Hermes instead of OpenClaw (the stock default)
Supermemory dropped for the default Hermes memory (recommended by Teknium, who leads Hermes)

The agent

The brain is now Hermes, the agent from Nous Research. It runs as a gateway service on the Pi and talks over whatever channels you wire up. Bring your own model (I point it at OpenRouter) and pick it in a little web dashboard. Caddy sits out front, serving the setup page and proxying the backend. Nothing fancy, just the parts I trust doing the jobs I want.

Memory

This is the part I went back and forth on. I started by self-hosting Honcho as a memory backend: Postgres, pgvector, Redis, a deriver worker, the whole Docker stack. It worked, and it was also a fragile, RAM-hungry pile of moving parts for what it actually bought me on a 4 GB Pi.

So I ripped it out. The default Hermes memory is just a small MEMORY.md the agent keeps current, plus skills it writes for itself. No vector database, no embeddings bill, and a lot less to run.

Reaching it

The Intern lives on my desk, but I don't want to be at my desk to use it. Tailscale handles that. The dashboard is published to my tailnet only, SSH goes over the tailnet, and a firewall locks the rest down so nothing interesting is exposed to the local network. From my phone or my laptop, anywhere, it's just there.

The LEDs

Those flashing LEDs aren't just for show. The backend drives the ring to track what the agent is doing. On my build, getting it to follow Hermes took a small bridge that feeds Hermes' activity to the backend's LED API, so the ring breathes one color when it's idle, another while it's thinking, another while it's running a tool.

The Rabbit R1

There's one more goodie in the script: a shim that lets you pair a Rabbit R1 to the Intern using the R1's built-in OpenClaw pairing. Scan a QR and the R1 becomes a pocket remote for the agent. I wrote that part up on its own: Replacing Rabbit's Brain.

One script

It's all one script. Flash a Raspberry Pi 5 with Debian Trixie, run it, and you get the whole stack: agent, web layer, memory, remote access, LEDs, and the optional R1 channel. It's idempotent, so you can re-run it without thinking too hard, and it works out on its own whether to run wifi onboarding or use a connection you've already got.

Repo's here: github.com/iammatthias/intern.

Toy GPTs

Tue, 02 Jun 2026 16:11:44 GMT

Back in February, Karpathy released microGPT, 200 lines of dependency-free Python that trains a GPT: a scalar autograd engine, a small transformer, an optimizer, and a train loop, with nothing to import. It rattled around in my head for months. Two side projects came out of it.

Meet Bard and Dead Presidents.

Bard is a tiny GPT trained on Tiny Shakespeare whose weights live on Ethereum. Dead Presidents is trained on the inaugural and State of the Union addresses of presidents who have died.

What a GPT is, roughly

A GPT predicts the next token from the tokens before it. Show it enough text and it learns which token tends to follow which. To generate, you hand it a few tokens, ask what comes next, append the answer, and ask again.

Both of these work one character at a time. The token is a single letter, space, or punctuation mark. Bard has a 66-character vocabulary, Dead Presidents has 34. They read a run of characters and guess the next one.

These models continue text. Hand Dead Presidents "the state of the" and it runs with it, in the cadence it learned.

Bard

Bard trains offline in numpy, then puts its weights on chain. It is 811,520 parameters: 4 layers, 128 wide, a 64-character context. After training, an export step quantizes the weights to int8, gzips them to 684 KB, and hashes the result with SHA-256. That artifact goes on Ethereum.

Normal contract storage would make 684 KB cost a fortune, so the weights ride on SSTORE2, which stores each chunk as the bytecode of a throwaway contract and reads it back far cheaper. The artifact splits into 29 chunks of 24,000 bytes, so the model lands on chain across 29 transactions inside a WeightManifest.

A CREATE2 salt grind lands the contract at a vanity address starting 0xBA2D. ba2d is bard in hex. The deploy commits that address first, empty, then sets the config (including the artifact hash) afterward, which keeps the address independent of the model. Once the uploader pushes and verifies every chunk, the owner calls seal() and freezes the manifest for good.

Inference happens in the browser. The frontend reads the 29 chunks straight off chain, reassembles them, gunzips, and checks the SHA-256 against the contract's hash. It runs only on a match, which proves the weights in the browser are the ones the owner sealed. Then it generates Shakespeare-shaped text, a character at a time. This is a Sepolia testnet proof of concept, and at this size the output reads as Shakespeare without quite cohering.

Dead Presidents

Dead Presidents points the same architecture at American political speech. The corpus is every inaugural and State of the Union address from presidents who are no longer with us, George Washington in 1789 through George H.W. Bush. The corpus leaves out the five living presidents, which means the builder keeps george_bush and drops george_w_bush. That comes to 255 addresses, normalized into 30,725 lowercase sentences, around 3 million characters, a 34-token vocabulary. The State of the Union speeches are the bulk of it, and they pull the diction toward the administrative: secretary of the treasury, expenditures, appropriations.

There are two engines for one model. The scalar engine is pure Python with no NumPy, running at about 8 seconds per training step. Every multiply and every gradient is a visible Python object, which makes it readable and unusably slow. The fast engine is the same math in NumPy at roughly 5,400 examples a second. They agree to machine precision, logits matching to about 1e-16, so you train on the fast one and sample through the slow legible one and get the same numbers.

Slow training makes good weights expensive, so finding them became its own search. The search copies Karpathy's autoresearch loop: one metric, a fixed step budget per run, keep the result if it improved. The metric is val_bpc, bits per character on a held-out split. Seven researcher agents each took one region (width, depth, learning-rate schedule, batch size, context length, attention heads, and a wildcard combo) across 59 experiments, then re-ran the top configs on three seeds to reject luck.

Warmup mattered most. Without a 150-to-250-step warmup, every bigger model looked worse, an init-time instability that masqueraded as a capacity ceiling. Context length came next: block size 24 to 112 dropped the metric the whole way. Depth beat width at matched parameter counts.

The numbers in one line: 5.09 to 2.04 to 1.667 to 1.530 to 1.475 bits per character. Untrained, then inaugural-only, then adding the State of the Union speeches, then scaling the model up, then training straight across sentence boundaries instead of one sentence at a time. The winner is 464,928 parameters (96 wide, 4 layers, 192 context), about 1.8 MB as float32.

The samples come out unmistakably presidential and not quite grammatical:

the constitution of the country and personal agreement has been made in the state of the union.

our efforts is the soviet union and the prosperity of the secretary of the united states.

One phrase reaches back to the 1800s, another to the Cold War, both from 34 characters and 465k parameters. It runs client-side too. A Web Worker holds the weights behind an OpenAI-shaped API, and the chat UI seeds from your message and continues in dead-president voice, a séance with live token counts.

Farfield

Both ship their weights to the browser and run them in a Web Worker, a character at a time. They land on Farfield, the catch-all domain for my side projects and self-hosted services. Bard is live there now; Dead Presidents goes up today.

Adventures in Machine Vision

Tue, 02 Jun 2026 00:30:40 GMT

A Nat Friedman anecdote recently caught my eye:

Most of it is fluff. Friedman, Daniel Gross, and the Collisons are positioned to consume AI at a level most of us only read about: all the toys, all the tokens, early access, and people on payroll to wire it together. A lot of what gets demoed from that vantage point is a postcard from a budget I don't have. But the kernel of the idea is almost always cheap, you don't need their resources to point some consumer hardware at yourself and see what falls out.

Now I need to preface this by making it clear that blanketing your house with cameras and letting an AI watch you 24/7 sounds dystopian.

I want you to walk to the kitchen right now and drink a bottle of water, and I'm going to watch to make sure you do it.

Maybe dystopian is the wrong word. This is self-inflicted panopticon horror.

Let's build our own.

The build

I had a spare Raspberry Pi Zero 2 W rattling around in a drawer, so I gave it a job. A 5MP Arducam (the OV5647, a native Pi sensor, so no driver wrangling) rides the camera ribbon, and a repurposed Waveshare Environment Sensor HAT sits on the GPIO header. The camera and the HAT use different connectors, so they coexist on one board on my desk.

The pipeline is small. picamera2 pulls frames, a quantized TFLite SSD-MobileNet-v2 runs COCO object detection, and every confirmed sighting gets appended to a daily JSONL log. A read-only FastAPI service reads that log back out over my tailnet. The detector writes, the API reads, and they run as separate services so I can restart one without disturbing the other.

The Zero 2 W is the bottleneck: quad A53, 512 MB, around 2 to 6 FPS for full COCO. That's slow for video and plenty for "who or what just walked by." It debounces per label, so it records presence over time instead of flooding the log every frame.

It stores no video. Frames stay in memory unless I ask for them, and what lands on disk is metadata: one JSON object per detection with the label, confidence, and bounding box. There's a live preview too, off by default and tailnet-only, plain MJPEG that renders into an <img> and encodes on the Zero 2 W's hardware block instead of the CPU.

The HAT writes its own stream, polling temperature, humidity, pressure, and light every thirty seconds. The board heats itself, so the temperature reads high. A live reading of the SoC temperature feeds a thermal-divider model that subtracts the self-heating and pulls the number back toward the actual room.

Right now it isn't doing anything. It watches my desk and writes things down. But I have ideas:

track my water intake during the workday
turn the lights on and off depending on whether I'm actually at my desk
etc.