John Saad

Play · The Machine Behind the Map

JohnOS

A personal, terminal-native AI operating system: one assistant, a whole life’s context, plain files owned forever.

Every AI chat starts from zero. It does not know what you decided last Tuesday, which project is quietly on fire, or what your rules are; so you re-explain your life every session, and it hands back generic answers to specific problems. I got tired of employing a brilliant amnesiac.

So I built it an operating system. Not a kernel in the classical sense, but a life layer: a git-tracked vault of markdown where every fact and decision has one home, a rules file the assistant loads before it acts, small command-line helpers that let it read my real inbox and real calendar and real bank ledger, and a set of rituals that keep the whole thing honest. It lives in the terminal, because the terminal is where tools compose.

The result reads like science fiction and runs like plumbing. My mornings open with a briefing that already knows the day; my captures file themselves under the right project from whatever device is nearest; my sessions end with the record updated, the work committed, and tomorrow’s first move named. The machine serves the map, and the map is mine.

The parts

1

The kernel

one rules file, auto-loaded

A single file of house rules the assistant reads before it touches anything: how I write, what it may never delete, what “wrap up” means. When it gets something wrong, the correction becomes a rule with a date; the kernel is a constitution that grows one amendment at a time.

2

The vault

plain markdown, git-tracked

Every fact, decision, and open thread lives in one canonical markdown file among a few hundred, indexed and cross-linked; git gives it history, sync, and an audit trail. Ask what we decided in March and it quotes the file, with the date.

3

Tasks

a file, not an app

The task store is a local JSONL file with an auto-ranked queue; urgency, impact, and staleness are computed, not curated. “What’s next” returns one confident answer. Capture works from the terminal, the phone, or the watch, and everything lands under a project.

4

Senses

small CLIs for real surfaces

Email, texts, calendar, contacts, finances, deploys; each is a small command-line helper the assistant can read, so triage becomes a conversation. Reads are free; anything that sends or deletes is gated behind an explicit confirmation.

5

Verbs

skills as playbooks

Named routines written down as playbooks: walk the inbox, rank the queue, wind down the session. Say the phrase and the whole procedure runs; refine the playbook and the OS gets permanently better at that verb.

6

Rituals

the habits that keep it honest

A briefing at boot with the day’s state; a wind-down at close that updates the docs, commits, journals the session, and names tomorrow’s first move. The journal even classifies the misses: detour, rest, or avoidance.

7

The bar

ambient awareness

A one-line status bar under the terminal: project, focus, unread mail, texts, next meeting. Every segment reads a local cache and never blocks; the whole OS is visible at a glance without opening a single app.

The principles

  1. 01Files over apps; plain text you own outlives every platform.
  2. 02One context; a life is one system with one index, not silos.
  3. 03Terminal-native; what lives in the shell composes.
  4. 04Read before act; written rules beat remembered preferences.
  5. 05Rituals over discipline; the system survives on habits, not willpower.

Build your own

JohnOS is not a product; you cannot install someone else’s life. It is a method, and the method is teachable: the vault, the kernel, the task store, the senses, the verbs, the rituals, built in a weekend and grown for a lifetime.

I am turning that method into a course. If you want your computer to work this way (one assistant, your whole context, files you own forever), leave your email and you will be the first to know when it opens.

watch it run: press > anywhere and type demo.