I’ve written about Sebastian twice before: once when he was a Caribbean-accented, monocle-wearing AI crab running our family’s digital life on OpenClaw, and once when we rebuilt him on Open WebUI and Ollama. Both posts covered pieces. This one is the whole machine, because the system has grown into something I couldn’t have described a year ago: a household AI platform serving six people from a mini PC in the living room, on two subscriptions and an electric bill.
We call the integration layer pairvis. The name is a double take: a parvis is the open court at the threshold of a building, and pairvis is a literal pair of views. That’s the entire idea in one line. One brain (our local couch computer) and two views (OpenWebUI and Theia)
The Hardware Nobody Sees
The brain is the couch computer: a small AMD mini PC with 32GB of RAM whose integrated GPU runs our local models. It holds every family project, every chat, every automation, and it is not reachable from the internet at all. The second machine is a small rented VPS, the edge: it has the public IP, the TLS certificates, and a reverse proxy that forwards our family domain to the brain over a Tailscale tunnel. The placement rule that settles every argument: if it needs a public IP or must answer from outside 24/7, it lives on the edge. Everything else lives on the brain.
The third machine is the one I enjoy telling people about: an old Android phone with a 1TB SD card, sitting in a fireproof vault on a battery backup. Every night the brain sends it encrypted snapshots and plain tarballs of everything. It is the cheapest off-machine backup target I’ve ever run, and it has already earned its keep.
Two Views, One Assistant
Everyone in the family gets the same two surfaces. The chat view is Open WebUI, where Sebastian answers questions, runs the household, and remembers. The code view is Eclipse Theia, a full browser IDE, one container per person, each mounting only that person’s own projects. Same assistant in both. Same files in both. A project started as a chat folder shows up in the IDE within a couple of minutes, already a git repository, already pushed to an off-box remote, without anyone knowing what git is.
Under both views sits a capability server we call the spine. It speaks MCP and exposes the same tools to chat and IDE alike: read project files, check git status, publish an app, schedule an automation, search Sebastian’s memory, delegate real coding work. The faces are thin. The spine is the system.
The Subscription Math
AI pricing wants every human to have every subscription: a chat plan each, a coding plan each, times six. Our answer is that the house is the subscriber, not the person.
Chat runs on Ollama: local models on our own hardware for free, plus one flat-rate Ollama Cloud account for the heavier conversational models. Coding is delegated: when anyone asks Sebastian for real code work, in chat or in the IDE, the task routes to a coding agent on the box. By default that’s Claude Code on one Claude subscription whose credential lives on the server and serves every family member’s session, still doing exactly what a coding subscription is for, just for a household instead of a hobbyist. Anyone can flip their personal setting to OpenCode on Ollama models instead and spend no Claude subscription budget at all. Nobody in my family but me has an account with an AI company, and nobody else needs one.
Projects That Cannot Fall Through the Cracks
Every project lives at one canonical path on the brain, one folder per person per project. A sync service watches both directions: make a folder in chat and the directory appears on disk; make a directory on disk and the chat folder appears. The same service puts git under every project and creates an off-box remote automatically, so the day a family member starts something, it is already protected. They never see any of this. They just notice that nothing ever gets lost.
Publishing works the same way: ask Sebastian to publish a project and it becomes a live app on a subdomain, running on the edge in a sandbox that keeps app code read-only and app data separate. Retiring works the same way too: everyone has Archive and Delete buttons for their own projects in the settings page, with the guardrails you’d hope for. Typed confirmation for delete, a refusal if the project is still live as a published app, and a quiet safety copy kept just in case.
Automations, and the Night Everything Failed Silently
Scheduled jobs are projects too: small Python files with a schedule, discovered by a daemon, posting their results into family chat channels as Sebastian. A news digest, a chat-repair watchdog, the nightly memory work. Nothing self-modifying runs without passing a validation gate first, a static check plus a sandboxed dry run that must come back clean before the scheduler will touch it.
The most important automation exists because of the worst thing that happened to this system. The vault phone’s SSH daemon died one night, and both backup paths failed silently for eighteen days. Journal errors nobody reads, no snapshots, no tarballs, and one project born inside that window lost its git history for good. The lesson is now doctrine here: silence must be treated as failure, never success. A sentinel checks every backup’s age each morning and posts to the family status channel only when something is stale, plus one weekly all-green heartbeat so we know the sentinel itself is alive.
The Grimoire: Memory Without Leaks
The newest layer, and the one I wrote about last time, is Sebastian’s memory. His identity lives in one file, stamped into every model automatically. His knowledge lives in a git repository we call the grimoire, and a nightly librarian job distills the family’s activity into it under one rule:
Solutions are shared by default and de-identified. Stories are attributed by default and detail-free. People can opt out of stories, and promote anything of their own.
Ask Sebastian about an error the house has seen before and you get warmth and substance at once: someone and I fought this exact thing Thursday, here’s the fix. Press for details that aren’t yours and he’ll tell you, kindly, that it’s their story to tell. The trick is that discretion happens at write time, once, by a strong model applying a written policy, not at chat time by willpower. Each person’s session only ever loads shared knowledge plus their own private memory. A fully jailbroken Sebastian cannot leak what is not in his context. Every family member has two consent checkboxes controlling whether he keeps personal memory of their work and whether he may mention them in happenings at all. The full technical spec, layer model, librarian policy, and the implementation gotchas are here.
What It All Costs, and What’s Next
Six people. Chat with memory, a full IDE, automatic project protection, one-click app publishing, nightly automations, and an assistant who remembers the house. Two subscriptions, one rented VPS, one electric bill, and an old phone in a vault.
Next up: there’s an Intel Arc Pro B70 with 32GB of VRAM about to go into the couch computer, which brings a frontier-class local model, and after that a local image and video generation agent built on the same delegation pattern, using MiniMax H3’s open weights. The philosophy hasn’t changed since the first post: steal ideas, not frameworks, and build for the people actually living in the house. The crab abides. Not bad for a couch computer.
