CarWatch

🎬 v0.4: talk to your car — watch the release video

Three questions asked by voice in the driver's seat and answered out of the car's own speakers — status brief, the yellow tyre light with real pressures, and E10 fuel from the manual. The last one with the internet switched off. Watch on X · download the video · v0.4.0 release notes

Your car as a chat-room agent — fully offline. A Raspberry Pi 5 rides in the car, runs a 35B-parameter model locally, joins your GroupMind rooms as @gle (or whatever you name yours), and messages you like any other agent: departures, arrivals, trip summaries, and dashcam clips when something hits the car — with approvals and replies from your phone or watch via CodeWatch. Open PRs land on the CodeWatch dashboard next to ClawWatch and WhereWatch.

Live and measured, on real hardware (Pi 5, 16 GB, ~300 €):

• 🧠 Qwen3.6-35B-A3B (Unsloth UD-Q3_K_S dynamic quant, 14.3 GB) at 3.5 tok/s generation / 25+ tok/s prompt, 65 °C sustained, no cloud, no internet, no subscription.
• 📖 Answers from the car's own 489-page owner's manual with page citations (lexical RAG, ships on the SD card) — and refuses to answer what the manual doesn't say.
• 🔬 Grounded self-knowledge: temperature, throttling, fan, memory, disk, network and which model is loaded are read live from the machine per question. What it can't sense, it says it can't sense — the system prompt is built so an unknown can never silently read as a fact.
• 🎙️ Hands-free voice: a continuous listener (energy VAD → whisper.cpp, all on-Pi) hears you speak, routes the words through the same grounded pipeline, and answers into the room. No wake word ceremony, no cloud STT.
• 📦 Zero dependencies: every line of CarWatch is Python standard library — no pip install, no venv, nothing to version-fight on a fresh Pi OS. git clone and it runs. (Verified by AST scan of every module.)
• 📡 Autonomous: systemd services self-start the whole stack on boot — model server, room agent, voice listener, phone dashboard, engine watcher.
• 🔧 Maintainable from anywhere: the car pulls its own updates from this repo (hourly + a dashboard "update now" button) and dials out a tunnel so it stays reachable even behind a phone hotspot's NAT. No laptop-in-the-car maintenance, ever.
• 📶 Three-tier connectivity: phone hotspot → home wifi → its own fallback access point, so the phone can always reach it, even in a garage with zero signal.

🧠 Swap the car's brain from your phone (v0.5)

Different questions want different brains. "What does the tyre light mean?" is a 489-page-manual question that deserves the 35B. "How fast am I going?" is not — and on a Pi the small model answers it six times quicker. So the dash grew a Model zone: every .gguf on the box, listed with the speed it actually reached on this Pi, and one tap to make it the running brain.

The numbers next to each model are llama-bench runs from the device itself, not figures from someone's blog — the same hardware, the same quant, measured the same way, so the choice you are making is a real trade and not a guess. The reference Pi 5 16GB table (29 Aug 2026, 4 threads, prompt pp512 / generation tg128 in tokens per second):

Sizes are decimal GB — size / 1e9, the same number the dash shows you and the same number ls gives for the file. The table grows as models get benched on the device; the menu always shows whatever the box has measured for itself.

Three guard rails, because this runs while you drive:

• A model that cannot fit in RAM is refused, with the reason, instead of loading until the kernel kills something.
• A swap never interrupts an answer being generated. Ask first, swap after.
• A failed restart rolls back to the model that was working.

Loading is honest about itself: a 14 GB model off a microSD card takes about three minutes, so the dash says so and counts, rather than showing a spinner that means nothing. The estimate is derived from the size of the model actually being loaded.

Underneath it is two endpoints behind the same auth gate as every other route — GET /api/models for the registry and current state, POST /api/model for a guarded swap — and the service reads its model from an EnvironmentFile, so switching is a file write plus a restart rather than an edit to a unit file. That contract is deliberately small and device-agnostic: it is the first CodeWatch Fleet module, and the same two endpoints now answer on other machines in the fleet.

Remote access (manufacturer cloud while driving)

The manufacturer-cloud section reads your car's data through a Home Assistant instance at home. On the road the Pi can't reach your home network, so that section needs a private path back to Home Assistant. The free, own-your-data answer is Tailscale: your Pi and your HA machine join your own encrypted mesh, and the Pi reaches HA at a stable private IP from anywhere — home wifi never exposed to the internet, no subscription, nothing routed through us. Full setup in docs/remote-access.md. (The OBD readings need none of this — they come straight from the car.)

Use cases: the car is one of your agents

The point of a car that lives in your chat rooms is not a dashboard with a chat box. It is that the car can perceive, remember and speak in the same rooms as your other agents (house, phone, watch, pendant), so things happen without you asking. Petrus's own examples from the launch thread, sorted by the repo's honesty rule: proven happened on the real car, built exists in this repo but has not met the car, enabled is what the architecture makes possible the day the other side has an agent too.

More that follow from what the car can already sense (added by the team, same labels):