Enterprise seller based out of Chicago. Local-first AI enthusiast. Former college ballplayer, restaurant owner, avid golf trip attender, and the drawings are mine. Socials are down at the bottom if you want to connect.
Private things stay on my own hardware. The cloud still does the hard thinking — it just never sees the parts that are mine.
About
I'm an enterprise account executive in Chicago, covering the Midwest. Nine years of selling technology to large organizations, mostly to people who have been sold to badly before and can tell immediately when it is happening again.
Somewhere in there I started building the tools I kept wishing existed. It got out of hand. There are now a couple hundred small programs running on a machine at home — they watch my calendar, index what I read, sort my inbox, run models I fine-tuned myself, and tell me when one of them has broken.
The rule I build by is that private things stay on my own hardware. A small local model reads anything sensitive and hands the cloud a summary instead of the document. The cloud still does the hard thinking. It just never sees the parts that are mine.
The other rule is that a language model may propose but never commit. The thing that actually writes to disk, moves money, or sends a message is always plain deterministic code with a switch I can flip. Agents draft. Code decides.
The drawings on this page are mine too. Same pen, same habit — start somewhere and let the pattern find its own edges.
Elements
A curated slice of what runs at home. Not everything here is public, and some of it never will be.
A four-role sales department, staffed by agents
Turns the exhaust of everyday sales work into briefings. Four agent roles share one local data pond; a full account brief renders in under a second, offline, with no model call. Customer data never enters the repo — only aggregate counts do.
A dashboard that leads with what is NOT running
Local models, inference, hardware, and evaluations — with idle models and stale runs shown first. Honest dashboards are rare; most of them only show you the green.
A protocol server so agents can talk to my local models
Wraps a local model workspace behind the Model Context Protocol, so any compatible agent can query documents that never leave the machine.
Turns a codebase into a map an agent can actually read
Indexes a Python project into linked notes, one per symbol, so an agent loads the architecture up front instead of grepping blind. Makes the blast radius of a change visible before the edit.
Replaced the smart-home app with something I control
A local hub and a small web app on my own network. The browser can only call an explicit list of allowed actions per device type, so it can never invoke an arbitrary one. Reads keep working even when writes are switched off.
A voice assistant that runs on my own hardware
Local speech-to-text and local text-to-speech, with a tiered risk gate deciding what it may do on its own and what needs me to say yes first. Money and work systems are excluded at the capability level, not by a prompt.
Person detection at the edge, on real hardware
An always-on board watches for people and publishes to the home hub over a local message bus. The video never leaves the device — only the fact that someone is there does.
Routes each job by how sensitive its data is, not just what it costs
Every headless agent call falls through a chain of models. What decides the route is the sensitivity of the data in the prompt — private work stays local, everything else goes to the best available model.
One command to scaffold a new fine-tuning loop
After hand-building three nightly training loops, I generalized them. Scoring, classifying, and transforming loops now come out of one generator instead of a copy-paste.
Local model reads the private part; cloud model does the heavy lifting
A small model running on my own machine reads anything sensitive and hands the cloud a sanitized spec instead of the document. The good reasoning still happens in the cloud — it just never sees the private bytes.
The whole system as one page
A visual map of every agent, tool, and idea, written twice — once in plain language and once in the terms an engineer would search for. Protected items redact themselves by construction rather than by a setting someone could flip.
Nothing I run is invisible
Every morning it inventories every automation on the machine and writes one file describing each one's health, how brittle it is, and what it costs to run. The inventory is re-derived from scratch each night, so the labels cannot go stale.
Text a request from the road, get the work back
Send a message from a phone; a fenced headless agent runs a whitelisted action on the machine at home and texts back the result. The whitelist is the whole security model.
Measures its own blind spot and says so
Attributes token spend across thousands of sessions back to the agent that caused it, and reports plainly that it can only account for about a quarter of the total. A measurement that hides its own error bar is not a measurement.
Models
Each one takes over a job a frontier model used to do, on hardware I own.
So the cloud model never sees a private document
Blacks out personal information in my own paperwork before anything is sent anywhere. It retrains itself nightly and only promotes a new version when the new one leaks nothing and reads at least as well as the one it would replace. It is trained entirely on synthetic documents — my real ones are never used as training data.
Off-the-shelf, the base model caught about a third of what it needed to. Tuned, it caught all of it with nothing missed.
Learns my judgment so the big model only handles the close calls
Rates new open-source projects one to ten for whether they fit what I already run. It learns from the scores a frontier model gave, then takes over the easy calls and escalates only the genuinely ambiguous ones.
The stack
Every automation I run, scored on how likely it is to break. The broken ones are counted too.
