A workshop, left open on purpose

A public workshop of personal AI systems and local-first tools, built for myself and left open on purpose.

Hi, I'm Saagar. This site is a workshop, not a portfolio. It is a place I build personal AI systems, local-first tools, and joyful little experiments for myself, then leave the doors open so anyone curious can walk through. Nothing here is a pitch. It is the actual bench, with the actual tools on it, most of them one click from their source.

It is really one system

The honest version of what I do is small: I did not build dozens of things, I built one operating system, and it built the dozens of things. The center is a local-first operator OS that runs my projects from my own machine, drafts with a local model so nothing leaves it, and never acts without my say-so. Around that core grew the rest: a shared memory that keeps several AI assistants in sync, a nervous system for events, eyes that audit my whole portfolio on a schedule, desktop apps, interactive explainers, and a pile of field notes. Everything public traces back to that one machine.

Built for myself, in public

I build these because I want them to exist, not because a roadmap asked for them. That changes the incentives in a good way: the tools have to be genuinely useful to one demanding user, me, before they are anything else. Public is the default because the work is better when it has to stand in the open, and because the AI boom is more fun to learn through out loud. The one firm line is privacy: the parts that touch real data, like the mailbox the operator OS runs on, stay private by design. You get the architecture and the reasoning, never the data.

The throughline is verification

If there is a single idea under all of it, it is this: intelligence is now something you rent by the token, and the thing actually worth owning is the machinery that checks whether any system, an API, a plugin, a model, your own memory, is telling you the truth about itself. Nothing self-reports honestly. So I keep building small, owned checks, and I write about what they catch and where they stop. That argument runs as an essay series and, the long way, as a book.

What I'm working on now

as of 2026-06-26 · hand-updated

A snapshot of where my attention actually goes, not an archive. Everything below points to public surfaces you can inspect without exposing the private operating layer.

Sharpening the public pulse

This site is the project right now: turning a pile of personal AI systems into a public workshop that feels fresh without pretending to be live telemetry. The homepage pulse, fleet snapshot, and project index should show what is active, what is source-backed, and what intentionally stays private.

Building the Verification Chain

The throughline is verification capital: intelligence is rented, but the machinery that turns a system's self-reports into checked truth is the part that compounds. The cleanest entry point is Trust Doesn't Survive the Handoff, then the tools underneath it: MCPAudit, OPERANT, and GithubRepoAuditor.

Running the operator OS

Day to day I operate a small fleet of coding agents that coordinate through a single SQLite file, no message bus, no cloud. The Operator OS demo shows the architecture, an interactive explainer walks one task through the whole system end to end, and Fleet Mission Control replays a public-safe export of the real activity log. The control plane around it (mail, inbox, approvals, scheduling) stays private because that is the whole safety contract.

Next

Keep tightening the connective tissue: current-state framing, public-safe freshness dates, and clearer paths from the homepage into the Verification Chain, OPERANT, MCPAudit, GHRA, and the operator OS. If something here sparks a question, the portfolio and field notes go deeper.

What I build with

Not a gear-flex, just the tools that actually show up in the work on this site. The bias is consistent: local-first, plain files, and as little orchestration as I can get away with.

The agent fleet

• Claude Code and Codex for implementation, with Claude.ai for planning and longer-form thinking.
• A shared SQLite file (bridge-db) is the entire nervous system: every agent coordinates through it, no message bus, no cloud. The fleet snapshot shows a public-safe export.
• A local control plane (mail, inbox, approvals, scheduling, status) the agents reach over loopback HTTP.
• Field notes explain how the pieces fit.

Languages and frameworks

• Python (with uv) for the data, eval, and automation tooling.
• Rust + Tauri 2 for native desktop shells.
• Next.js + React and TypeScript for web work.
• Swift for iOS.

Local-first by default

• SQLite everywhere it fits: the data layer is a file you can copy, diff, and back up.
• Static HTML for anything public (this site is hand-authored HTML plus small Python generators, deployed to Vercel).
• Loopback services over cloud services; the machine is the platform.

Knowledge and verification

• An Obsidian vault of durable lessons and decisions, searchable through a custom retrieval layer.
• Enforced mechanisms over advisory docs: guards, gates, and evals that check the work instead of trusting it. That argument is the essay series.

How to look around

• Writing: the Verification Capital essays, including the keystone, plus the field notes.
• The book: the integrated argument, run at full length.
• Instruments: the public tools, packages, and benchmarks.
• Workshop: the things I've made, from apps to explainers.
• Receipts: the gates and trust machinery that keep the claims honest.
• Predictions: dated, falsifiable claims with explicit resolution criteria and a public scorecard.
• The fleet snapshot: public-safe exported telemetry from the operator OS, replayed from its own activity log.

Find me

I'm on LinkedIn, and the source for most of this lives on github.com/saagpatel. This whole page is a hand-built static file: no backend, no tracking, no analytics. If something here sparks a question, the work itself is the best answer I can give.