Build Your Own Agentic OS — the tabbed build console

What's new today

The build doesn't stand still.

A fresh, sourced idea or feature for your agentic OS — most days. Skim today's, then go switch something on. Older entries stay below so you can catch up.

Auto-curated. These daily entries are gathered automatically from public sources (each links to its source) and are pointers to explore — not medical, legal, or vendor advice. The permanent build tabs are the hand-built core.

Why an OS beats chat

Seed it with you — then watch it work.

No hype, no jargon. What an LLM is, what an agent is, and the five things that change the moment you give the model a home. Then pick your on-ramp below.

Where are you? Pick a door — it opens the right tab.

The basics

What this stuff actually is.

Four ideas, and the rest of this console falls into place.

01What is an LLM?

LLM stands for large language model. Picture an autocomplete that read an enormous slice of human writing — books, papers, code, the web — and got very good at one trick: given some text, predict what comes next. That's the whole engine. ChatGPT, Gemini, and Claude are all LLMs wrapped in a friendly chat box.

It isn't a database and it isn't a search engine. It doesn't "look up" an answer — it generates the most plausible continuation, a piece at a time. That's why it's fluent and creative, and also why it can sound completely confident and still be wrong. The fix — grounding it in your real files — is what the rest of this console is about.

For clinicians & scientists: because it's predicting plausible language, it can state a wrong fact — or invent a citation that looks flawless — with total confidence. Treat every fact, figure, dose, and reference as unverified until you check the source. That's exactly why the skills in this kit force every claim back to a real citation.

02How does it "think"?

It writes the way you might finish someone's sentence — a piece at a time, each choice shaped by everything before it. Newer models can also "think out loud" first (you'll see this as extended thinking): they work through the problem step by step before answering, which makes them far better at hard reasoning. But here's the catch that explains everything else: by default it remembers nothing between conversations. Close the tab and it has met you for the first time, again. Giving it a memory is move #1 of building an OS.

03What's a token?

Models don't read letters or whole words — they read tokens, the little chunks text gets sliced into. A token is roughly ¾ of a word (about four characters in English), so a phrase breaks into more pieces than you'd guess. Rough rule: 100 tokens ≈ 75 words.

"Ground your answers in my real files."

Groundyouranswersinmyrealfiles. → 9 tokens

Two reasons it matters. First, cost and usage limits are measured in tokens — you pay, or hit a cap, per token in and out. Second, every model has a context window: the most tokens it can hold in mind at once — its working memory, the size of its desk. Go past it and the earliest things slide off the edge. A bigger desk means it can read your whole CV and three papers at the same time, instead of forgetting the top of the page by the time it reaches the bottom.

04What do the different models do?

One company offers several models — not "old vs new," but different sizes for different jobs, like reaching for a scalpel vs a bone saw. Bigger models are smarter but slower and pricier; smaller ones are fast and cheap. You match the model to the task. Claude's current line-up is a clean example:

Opus

biggest · smartest · priciest

The heavyweight — complex reasoning, hard analysis, long multi-step agent work.

Sonnet

balanced · fast · everyday

The workhorse — a strong balance of intelligence, speed, and cost for most daily work.

Haiku

fastest · cheapest

The sprinter — quick answers, summaries, and high-volume simple tasks.

Model names current as of June 2026 — the line-up refreshes often and new tiers appear regularly. The principle (match the model to the job) doesn't change.

Source: claude.com/pricing

What's an agent

A chatbot talks. An agent does.

It's the word everyone uses and almost no one defines. Here's the whole thing.

A plain chatbot is a brilliant conversation partner: you ask, it answers, the loop ends. An agent is that same model handed three things — a goal, a set of tools, and permission to loop — so it can go get the goal done instead of just describing how.

Give it a goal like "organize this folder of papers and write me a summary," and an agent will look at what's there, make a plan, take an action (open a file, run a search, write a document), check the result, and repeat — until the job is finished. You stop dictating each step and start delegating the outcome.

The agent loop — it runs this on its own until the goal is met.

What gives it "hands"

Tools & connectors

Reach beyond the chat box — read your files, search PubMed, check your calendar, browse the web, run code.

Skills

Encoded workflows it runs the same way every time — your care pathways for cognitive work (more in the Skills tab).

Memory & files

It remembers, and it leaves durable artifacts behind — so work compounds instead of vanishing.

The loop

It chains many steps by itself, checking its own work as it goes, until the goal is actually met.

How much rope you give it

Agents run on a spectrum of autonomy, and you set it: from suggests what to do → does one step when asked → runs a whole multi-step task on its own. Think graduated responsibility, like a trainee — supervised first, independent only once it's earned your trust on the small things. A well-behaved agent pauses before anything irreversible — sending, deleting, publishing, spending — and asks first.

Where this lands: Cowork and Claude Code are agents with a real workspace. A mature OS is many agents + a library of skills + a knowledge vault, wired together across machines. Same handful of ideas, scaled up.

One honesty note: an agent is only as safe as the boundaries around it. Keep patient data out, review anything it sends or publishes, and let it ask before irreversible steps. Good AI hygiene scales with capability.

The flop → the fix

It's a world-class chief of staff who has never met you.

Open any chat and ask it to "plan my year to reach my career goals." You'll get fluent, confident, generic mush — because it has no idea who you are. It's brilliant, and it forgets you the moment you close the tab.

That's not a flaw in the model. It's a missing system. The fix is four moves: give it a memory, give it a filesystem, give it skills — and seed all of it with you: your CV, your papers, your goals. Do that and the same model that just flopped becomes a teammate that knows your whole world.

If you've tried these tools and walked away thinking "impressive, but a glorified autocomplete I can't trust" — you're not wrong. That's an honest verdict on raw chat. It's not a verdict on the system you can build around it.

Every tab to the right is those four moves, built up one stage at a time — and almost all of it is free to start tonight.

Five things change the moment you build an OS.

Same model, two completely different machines. The left is what you get from a chat window. The right is what you get when you give the model a home.

Raw chat

An agentic OS

Amnesiac — starts at zero every time

→

Remembers — context persists

Generic — built for everyone

→

Yours — built on your data

Improvised — as good as the day you had

→

Reproducible — runs your best workflow every time

Siloed — one conversation

→

Orchestrated — across tools, files, machines

Resets to zero

→

Compounds — more valuable the more you feed it

"Chat is something you use. An OS is something you build — and it pays you back forever."

The arc

It's a climb, not a leap. Six rungs.

You don't need all of it tonight. Each rung adds one capability, and you can stop wherever it's already paying off. Here's the whole ladder — and exactly where free ends and a paid plan begins. Each rung has its own tab.

RUNG 1chatOne conversation. Brilliant, ephemeral, single context.Free

RUNG 2ProjectChat + persistent files & instructions. It finally remembers who you are.Free

RUNG 3CoworkClaude's no-terminal agent app — a real workspace that reads whole folders, runs skills, and leaves files behind.Paid

RUNG 4Claude CodeSame power, in a terminal — for the technical crowd.Paid

RUNG 5ObsidianSee the graph. Your notes become linked nodes you can walk through.Free

RUNG 6At scaleAll of it — a skill library + vault + connectors across machines.Mature OS

You are here → Rung 2. A Project seeded with your CV, goals, and a couple of papers is the whole personal-OS core, and it's free. That's the first build (). Rungs 3–4 are the paid agentic workspace ( / ); Rung 5 (Obsidian) is free again; Rung 6 is just these same ideas, accumulated over a year ().

Why the jump from Project to Cowork is the real one

In a Project, your files persist — but it's still a conversation. The agent talks about your work. In Cowork (or Claude Code), the agent has a real workspace: it can read a whole folder of papers, run multi-step work, execute skills, and create files. It operates on your world and leaves durable artifacts behind.

Chat: resets to zero

An OS: compounds

An agent isn't a smarter chat — it's a worker with hands. You stop asking and start delegating.

Skills

A skill is a care pathway for cognitive work.

Write your best workflow down once, and the agent runs it perfectly every time — even post-call, even when you don't have the energy to structure it yourself. Encode the best process once, kill the variability, guarantee the floor. Same reason we use checklists in the OR. Full kit + copy blocks are in the Skills tab.

Messy inputs

A PDF, a folder, a half-formed ask

→

⚙ Encoded skill

Your steps + rules, written once

→

Consistent output

The same high-quality artifact, every time

Chief of Staff

Reads your OS + a deadlines note and hands you a prioritized briefing: what's urgent, what's due, the next concrete action, and one strategic insight you'd have missed.

Paper-ingest

Drop a paper, get a permanent linked knowledge node — citation, findings, methods, why-it-matters-to-you, verified refs — instead of a throwaway summary.

Presentation-ingest

Drop a talk, get a structured talk node: thesis, the mental model it teaches, key claims, figures, and links back to your work.

The compounding

The graph is the part you can see.

Wiki-links, backlinks, and a graph view turn your notes into an external memory that gets smarter as it grows. Every paper, every talk, every meeting becomes a permanent, linked node — instead of a memory that fades by Monday. Turn it on in The Graph tab.

Watch it grow — each node links into the ones already there.

A [[wiki-link]] is you telling your second brain "these two ideas are related." Backlinks mean every note knows who points at it. The more a note is referenced, the bigger it grows. That visible web is the compounding — and you'll grow it live, in Obsidian, with papers pulled straight from PubMed.

Where next →

Stage 02 · Square One

Never opened Claude? Start exactly here.

What this is

The absolute beginning: make an account, install the few free apps, and understand the one thing you'll pay for and the (large) amount you won't. By the end you have a working account and an empty Project ready to seed.

Why a surgeon-scientist wants it

Everything else on this page hangs off one free account. Fifteen minutes now and the rest of your career's scholarly context has a home that remembers you — instead of re-explaining yourself to a blank box every time.

Tier Free to start Paid only for Cowork/Code Yours forever

Free vs paid — the honest version

The whole personal-OS core is free: chat, Memory, file creation, and up to five Projects. You only pay when you want the agentic workspace — Cowork (no terminal) or Claude Code (terminal) — which need a paid plan. So: build and feel the entire idea for $0; upgrade later only if you want the hands-on agent. Free covers tonight.

⛔

One hard rule, from the very first minute: no patient information, ever. A personal account has no institutional data agreement (no BAA), so this is for your own scholarly materials — CV, your published papers, public data — never patient data or anything pulled from your institution's systems. Clinical/PHI work belongs in an institution-approved, BAA-covered tool.

Set it up — the free apps ~15 min · no terminal

This stage lives on the web + desktop app — no terminal anywhere. Install these four; the first one is all you strictly need tonight.

1 · Claude account Free

What it is: the AI itself. What it does: Projects + Memory are free — your whole personal-OS core lives here.

Get it → claude.ai

2 · Claude Desktop Free app

What it is: Claude as a desktop app. What it does: hosts Cowork and the connectors (MCP) that reach your files, PubMed, and calendar.

Get it → claude.ai/download

3 · Obsidian Free

What it is: a free, local markdown app. What it does: your knowledge vault + the graph view that shows it grow.

Get it → obsidian.md

4 · Zotero Free

What it is: a free reference manager. What it does: stores your PDFs + citations so the literature graph has something to link.

Get it → zotero.org

Make your first Project (the empty shell)

Sign in at claude.ai (Free is fine).
In the left sidebar, open Projects → Create Project. Name it My OS.
Make a folder on your computer called My-OS/ — that's where your source files and your Obsidian vault will both live.
Don't burn your daily message limit poking around — you'll want it for the build. That's it for Square One.

✅

Done when… you can open the empty My OS Project and you have a My-OS/ folder on disk. Now go fill it.

Where this connects →

Stage 03 · OS Core (Project + Memory)

Seed it with you — the move that turns chat into a chief of staff.

What this is

A Project seeded with who you are — CV, goals, a couple of papers — plus a custom-instructions block that tells it how to help. This is the free personal-OS core (Rung 2), and it's the whole first build.

Why a surgeon-scientist wants it

A chief of staff that knows your CV, your papers, and this week's deadlines — so "plan my year" stops being generic mush and becomes specific, grounded, cited-to-your-files advice.

Tier Free · Projects + Memory, no terminal

① Before you begin — bring four things

Your CV
Your personal statement — or a short bio / career snapshot
Your career goals — even a few bullets is plenty
1–3 of your publications — abstracts or posters are fine if you're early

Have a Claude.ai account ready. Free covers this core build. And don't burn your daily message limit right before we start — we'll send ~10 prompts together. (See the privacy note in for the free-tier nuance on personal statements.)

② The folder + the seed

Keep your OS files in one folder so Obsidian can graph them. Then fill in _ABOUT_ME.md — it's who your OS thinks you are; everything else hangs off it.

My-OS/ — suggested layout

My-OS/
├── _ABOUT_ME.md            ← who you are (the seed)
├── deadlines.md            ← what's due (for the Chief of Staff)
├── Literature/             ← paper-ingest drops nodes here
├── Talks/                  ← presentation-ingest drops nodes here
└── skills/
    ├── chief-of-staff.md
    ├── paper-ingest.md
    └── presentation-ingest.md

_ABOUT_ME.md

# About Me

## Identity
- Name / role: [your role — e.g. Surgeon, Researcher, Resident, PhD student, Clinician-educator]
- One-line: [who you are professionally]

## Career goals
- Short term (this year): [...]
- Medium (residency): [...]
- Long term (the career you want): [...]

## My work / interests
- Clinical interests: [...]
- Research themes: [...]
- Publications: [list — these also live as PDFs in this folder]

## How I want help
- Voice: [direct / concise / etc.]
- Defaults: prioritize ruthlessly; give me the next concrete action;
  ground answers in my real materials; cite which file you used.

## Standing rule
- Never include patient-protected information in this system.

③ The custom instructions for your Project

Open your My OS Project, upload your four files, and paste this into its custom instructions. This is the move that turns a chat into a chief of staff who knows you.

My OS — custom instructions

You are my chief of staff. You know me from the files in this project —
my CV, personal statement, career goals, and publications. Always ground
your answers in my actual materials and cite which file you used. Be
specific and direct. When I ask what to do, prioritize ruthlessly and
give me the next concrete action, not generic advice.

Try it: ask your seeded Project "given my goals and what's due, what should I focus on this month?" — and feel it answer as someone who actually knows you. The full Chief of Staff skill (a copy-paste file) lives in the .

✅

Done when… your My OS Project holds your CV + goals, the custom instructions are pasted, and it gives you a specific answer that cites one of your files.

Where this connects →

Stage 04 · Connectors (MCP)

Give it hands — turn the connectors all the way on.

What this is

A connector (MCP — Model Context Protocol) is a standard plug that lets an agent reach an outside tool: your files, PubMed, your calendar, Drive, Gmail, Slack. Add one once and the agent can use it in any conversation. Think USB for AI — one port, many devices.

Why a surgeon-scientist wants it

Ask a clinical or research question and get an answer with a verifiable citation list — not a confident guess. The PubMed connector is the single highest-leverage switch: it turns "sounds right" into "here are the PMIDs."

Tier PubMed + Files connectors: free in Projects/Desktop

Connectors worth turning on

Reach your world

Files (your own folders) — read & write a folder of your files. The heart of Cowork.
PubMed — search the literature and write linked notes straight into your vault.
Google Drive — pull in docs, slides, and sheets you already have.
Calendar — let the Chief of Staff see what's actually on your week.
Gmail — triage and draft from real threads (review before sending).
Slack — capture and triage messages into action items.

The PubMed payoff

With PubMed wired in, your Chief of Staff and your paper skills stop guessing. Every claim can be resolved to a real PMID/DOI, checked for retractions, and graded for evidence — the same discipline behind the integrity check in the tab.

Two ready-to-paste builds that use the PubMed connector — research-identity and literature-graph — live in the .

Set it up — two paths

🖥️ In Claude Desktop / Cowork no terminal

Open Settings → Connectors.
Add the one you want (Files, PubMed, Google Drive, Calendar…) and approve the access it asks for.
Grant the narrowest access that does the job; disconnect anything you're not actively using.

🔶 The exact menu names move between versions — the shape ("Settings → Connectors → add & approve") is stable even when the labels shift.

⌨️ In Claude Code terminal

Run the add command and follow the prompts:

terminal — add a connector

# interactive: pick a server and follow the prompts
claude mcp add

# list what's connected
claude mcp list

Project-scoped servers can also live in a .mcp.json file — see the .

Use OpenEvidence — clinical literature, safely evidence

Goal: bring OpenEvidence's cited clinical answers into your OS — as a guarded lead, never the final word.

OpenEvidence isn't a live connector you plug in — it's a web tool. Ask it a focused clinical question at openevidence.com; it answers with a "Cited Sources" list.
Bring it in by hand: copy the answer and its Cited Sources into a note in your OS folder.
Then verify — always. Treat OpenEvidence (and any AI answer) as a lead, not a citation. Run each source through PubMed before it earns a place in your notes.
No patient information in the query, ever. Ask about the condition, not the patient.

Why the extra step: a fluent answer with confident-looking citations can still be wrong, or point to a paper that doesn't actually say what's claimed. Verifying every source is the whole discipline — the same reason the paper-ingest skill checks citations against PubMed.

🔒

Golden rule for every connection: only connect what you trust, never route patient data through a personal account (no BAA), and review anything an agent sends, posts, or publishes before it goes out.

✅

Done when… you've added the PubMed connector and asked a question that comes back with a real, clickable citation list.

Where this connects →

★ Stage 05 · Flagship — Zotero + Papers

Make your OS completely aware of a paper — with an integrity check.

What this is

The whole path: turn Zotero on (both layers), drop in a PDF you've marked up, and get back a linked Markdown node your OS can answer questions about — every reference resolved, retraction-checked, and graded. Not "get an API key." The full loop.

Why a surgeon-scientist wants it

Turn a pile of PDFs into a queryable, integrity-checked library wired into your ideas — and never re-read a paper from scratch again. The graph remembers what you read so you don't have to.

Tier Zotero + reading: free folder-scale ingest: Cowork/Code

The pipeline, end to end

PDF (your highlights) → verified identity → MD node → integrity check → Zotero mirror.

① Turn Zotero on — both layers

Read layer — Local API no key

Run the Zotero desktop app, then Settings → Advanced → "Allow other applications on this computer to communicate with Zotero." It exposes http://localhost:23119/api/ — fast, local, and read-only. Great for "find the papers in my library on X."

Write layer — Web API key required

The local service can't add items. To write, create a personal key: zotero.org/settings/keys → "Create new private key," grant library read/write, copy it (shown once). Your numeric userID is on that same page.

🔑

Treat the key like a password. Store it in your password manager, hand it to the tool when it asks, and never paste it into a chat or commit it to a repo. On this page everything uses placeholders — <your-userID> and <your-key> — and so should your notes.

② The dual-layer mental model

One paper, two homes, linked: Zotero is the human layer (the PDF binary, your highlights, annotations, mobile access); your OS is the AI layer (a small Markdown node — citation, findings, why-it-matters, evidence level, status, and wiki-links into your theories/projects). The bridge is the node's frontmatter, carrying a zotero_key.

Literature/Author_Year.md — frontmatter (generic values)

---
title: "Short title of the paper"
authors: "First Author, et al."
year: 2026
doi: 10.xxxx/xxxxx
pmid: 00000000
zotero_key: 
litguard_status: PASS        # PASS | CONDITIONAL | FAIL
evidence_level: II           # I–V (study design)
tags: [literature]
---

③ Ingest a paper end to end

Drop the PDF (with your markup) into your My-OS/Literature/ folder.
Verify identity deterministically — the agent extracts authors / title / DOI from the PDF itself (a script reads the file), not from the model's memory. This is how you beat hallucinated citations.
Write the MD node — citation, 3–5 key findings, "why it matters to my work," evidence level, and ≥2 wiki-links to your theory/project notes. Now the OS can answer questions about the paper and it shows up in your graph.
Integrity check (LitGuard pattern) — every reference the paper leans on runs RESOLVE → VERIFY → ENRICH → REPORT: resolved against PubMed (PMID/DOI), checked for retractions, graded for evidence level, and scanned for overclaims (strong language on weak evidence). Output: a verdict — PASS / CONDITIONAL / FAIL — with a hard gate on retractions and hallucinations.
Mirror to Zotero — verified references import into a Zotero collection (auto-attaching open-access PDFs where available); the returned zotero_key is written back into the MD frontmatter. The loop closes.

Now your OS knows the paper — you can ask it anything, it's wired into your graph, and every claim traces to a real, non-retracted citation.

④ Copy blocks for this stage

An integrity-check prompt you can paste today (needs the ):

integrity-check — paste into Cowork or a Project

For each reference in this paper, find it on PubMed and give me:
1. the verified citation + PMID/DOI (say "NOT FOUND" if you can't resolve it),
2. a retraction / correction flag,
3. the evidence level (study design: RCT, cohort, case series…),
4. any claim in the paper that overreaches its cited evidence.
Return a table, then a one-line verdict: PASS / CONDITIONAL / FAIL.
Do not invent a PMID — if a reference doesn't resolve, mark it unverified.

The full paper-ingest (pro) skill — the base paper-ingest plus the integrity check and Zotero mirror:

skills/paper-ingest-pro.md

# Skill: Paper Ingest (Pro — integrity + Zotero mirror)

## Purpose
Turn a marked-up PDF into a verified, integrity-checked knowledge node
that is mirrored into Zotero. Extends the base paper-ingest skill.

## When to run
"Ingest this paper (pro)" + a PDF in Literature/.

## Steps
1. Read _ABOUT_ME.md so you know why this paper matters to me.
2. VERIFY IDENTITY from the file itself — extract authors, title, journal,
   year, DOI/PMID by reading the PDF (a script), NOT from memory. If a
   field is unsure, mark it "verify" — never guess a name or a PMID.
3. Write Literature/_.md with the frontmatter template
   (doi, pmid, zotero_key, litguard_status, evidence_level) + body:
   bottom line, methods, why-it-matters-to-me, >=2 [[wiki-links]].
4. INTEGRITY CHECK every reference the paper relies on:
   RESOLVE (PubMed PMID/DOI) -> VERIFY (retraction/correction) ->
   ENRICH (evidence level) -> REPORT (overclaim scan).
   Verdict: PASS / CONDITIONAL / FAIL. Hard gate: any retraction or any
   unresolvable ("hallucinated") citation -> FAIL, surface to me.
5. MIRROR to Zotero via the Web API (placeholders /):
   import verified refs into the collection, attach open-access PDFs,
   write the returned zotero_key back into the node's frontmatter.

## Rules
- Real citations only; verify against the PDF or PubMed. Never fabricate.
- Never print or commit the API key or userID — use placeholders.
- No patient data in this system, ever.

At scale this is a one-command skill (e.g. a paper-ingest / LitGuard pipeline with a Zotero write module) — Code path: a single skill on the folder; Cowork path: the same skill run on the folder, no terminal. Both honest about what's free (PubMed connector + Project) vs paid (Cowork/Code). The base paper-ingest.md lives in the .

The Zotero snag we hit (so you skip it) gotcha

The snag: the old one-click Zotero connector is gone, and the local read-only service silently refuses to write — so "add this to Zotero" can look like it did nothing. The Web API key above is the supported write path; that one detail saves an hour of confusion. In Obsidian, the Zotero + "Citations" community plugins pull your library straight into your notes.

✅

Done when… one marked-up PDF has become a linked Author_Year.md node with a PASS/CONDITIONAL/FAIL verdict, and (if you set the write key) a zotero_key written back into its frontmatter.

Where this connects →

Stage 06 · Cowork (Rung 3)

The agent workspace — no terminal required.

What this is

Claude's no-terminal agent app, inside Claude Desktop. Unlike a Project (which talks about your files), Cowork operates on a real folder: it reads whole directories, runs multi-step work, executes skills, and creates files you keep.

Why a surgeon-scientist wants it

Hand the agent a whole folder of a project's papers and data and get back a scaffolded summary, a reusable methods block, and a talk-ready deck — the kind of structuring you'd do on a good day, on every day.

Tier Paid (Pro or higher) · no terminal · research-preview

Set it up — and run a skill on a folder

🖥️ In Cowork (Claude Desktop)

Install Claude Desktop and sign in on a paid plan; open Cowork.
Point it at your My-OS/ folder (grant folder access — the narrowest that works).
Drop your starter skills into My-OS/skills/ (grab them from the ).
Run one: "Run my chief-of-staff briefing on this folder" or "Ingest this paper" + a PDF. Watch it plan → act → write a file back into your folder.
Open that file in Obsidian — it's already a node in your graph.

No dev stack needed here. Cowork is the whole point of "agentic without a terminal." If you'd rather work in a shell, the same power lives in the (which does need the developer install).

🔒

Same golden rule: no patient data through a personal account (no BAA), and review anything the agent sends or publishes before it goes out. Let it ask before anything irreversible.

✅

Done when… you've run one skill in Cowork and it has written a new file into your My-OS/ folder that shows up in Obsidian.

Where this connects →

Stage 07 · Claude Code (Rung 4)

The same power, in a terminal.

What this is

The terminal agent — same workspace abilities as Cowork (reads folders, runs skills, writes files), driven from your shell. Fully scriptable, and the natural home for project-scoped connectors via a .mcp.json file.

Why a surgeon-scientist wants it

Once you're comfortable, it's faster and fully automatable — the same folder-of-papers → methods-block → deck workflow, but repeatable from a command and easy to wire into project repos.

Tier Paid · terminal · runs on Node.js

Install the developer stack — in order

Install these in order — each builds on the last, and Node.js must come before Claude Code (Code runs on Node). On Mac, install Homebrew first; on Windows, use the official installers or winget.

macOS — paste into Terminal, in order

# 1) Homebrew (package manager)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# 2) Git, Node (LTS), Python
brew install git node python
# 3) Claude Code (needs Node)
npm install -g @anthropic-ai/claude-code
# verify everything
git --version && node --version && python3 --version && claude --version

Windows — paste into PowerShell, in order

# Git, Node (LTS), Python via winget (built into Windows 10/11)
winget install Git.Git OpenJS.NodeJS.LTS Python.Python.3.12
# restart the terminal, then install Claude Code (needs Node)
npm install -g @anthropic-ai/claude-code
# verify everything
git --version; node --version; python --version; claude --version

Run it, add connectors, run a skill

terminal — start in your OS folder

# from inside My-OS/
claude                 # start an interactive session here
claude mcp add         # add a connector (PubMed, Files…), follow prompts
claude mcp list        # see what's connected
# then just ask, e.g.:  "Ingest this paper (pro)"  +  a PDF in Literature/

For project-scoped connectors, drop a .mcp.json in the folder. Server names below are illustrative — use the packages your connectors document.

My-OS/.mcp.json — project-scoped connectors (illustrative)

{
  "mcpServers": {
    "files": {
      "command": "npx",
      "args": ["-y", "", "./"]
    },
    "pubmed": {
      "command": "npx",
      "args": ["-y", ""]
    }
  }
}

🔑

Secrets never live in the repo. Keys go in your password manager or a local environment variable the tool reads — never hard-coded into .mcp.json or committed. Use placeholders like <your-key> in anything you share.

✅

Done when… claude --version prints a version, claude mcp list shows a connector, and you've run one skill from the terminal that wrote a file into My-OS/.

Where this connects →

Stage 08 · The Graph (Obsidian · Rung 5)

See the compounding — your second brain, getting denser.

What this is

Obsidian opens your My-OS/ folder as a vault: every note becomes a node, every [[wiki-link]] a line between them. Backlinks, graph view, all built in — no account, no key.

Why a surgeon-scientist wants it

Every paper, talk, and meeting becomes a permanent, linked node instead of a memory that fades by Monday. The more you feed it, the more the web of your own thinking becomes something you can see and walk.

Tier Free · local · no account

Obsidian quickstart (5 minutes)

Install Obsidian (free).
Open folder as vault → choose your My-OS/ folder. Your markdown files become notes.
Make a link: in any note, type [[ and start typing another note's name — that's a wiki-link. The other note now shows a backlink.
Open Graph View (ribbon icon, or command palette → "Open graph view"). Each note is a node; each link is a line. The more a note is linked, the bigger it gets.
Grow it: every paper or talk you ingest adds a node that links into the graph. That visible web is the compounding.

Graph view, backlinks, and wiki-links are all built in — no plugins needed to start. Later: the Zotero + "Citations" community plugins for reference management, Dataview for live tables, and Claude's PubMed connector to write literature notes straight into Literature/.

The one thing that trips people up same folder

The vault folder and the agent's working folder must be the same folder. If your graph isn't growing, the agent is almost always writing somewhere Obsidian isn't watching — point Cowork/Code and Obsidian at the same My-OS/ and it springs to life. Have your agent write new notes into My-OS/Literature/, hit refresh, and the new nodes appear, already linked.

A [[wiki-link]] is you telling your second brain "these two ideas are related." Backlinks mean every note knows who points at it. The more a note is referenced, the bigger it grows — and the animated graph back on the is exactly what yours starts to look like.

✅

Done when… you've opened My-OS/ as a vault, made one wiki-link, and watched the first line appear in Graph View.

Where this connects →

Stage 09 · Skills

Encode your best workflow once. Run it perfectly forever.

What this is

A skill is a short Markdown file — your steps + rules, written down once — that the agent follows the same way every time. Messy input in, the same high-quality artifact out. A care pathway for cognitive work.

Why a surgeon-scientist wants it

Encode your best workflow once — paper-ingest, presentation-ingest, a literature sweep — the same way an OR checklist guarantees the floor. It runs perfectly even post-call, when you don't have the energy to structure it yourself.

Tier Lite: paste into a Project Full: a file in skills/ for Cowork/Code

Messy inputs

A PDF, a folder, a half-formed ask

→

⚙ Encoded skill

Your steps + rules, written once

→

Consistent output

The same high-quality artifact, every time

The three starters

Tap to expand. Each has a Copy button — grab the file, drop it in your My-OS/skills/ folder (or paste into a Project's custom instructions for a lite version).

Chief of Staff chief-of-staff.md

Total situational awareness, and what to do next — not a status dump.

skills/chief-of-staff.md

# Skill: Chief of Staff

## Purpose
Give me total situational awareness and tell me what to do next —
not a status dump.

## When to run
When I say "run my chief-of-staff briefing," "catch me up," or
"what should I work on."

## Inputs to read first
1. _ABOUT_ME.md — who I am and my goals
2. deadlines.md — what's due
3. Anything new in Literature/ and Talks/ since last time

## Output (in this order)
1. **Urgent (next 72h):** specific items + the single next action for each.
   Be concrete: not "work on manuscript" but "Draft figure-2 legend —
   it's the last blocker before submission Friday."
2. **This week:** the 3 things that move my goals most, ranked.
3. **One strategic insight:** a connection, opportunity, or risk I might
   be missing — the reason this briefing was worth reading.

## Rules
- Use my real files; never invent deadlines or facts. If a source is
  missing, say so.
- Tie recommendations back to my career goals in _ABOUT_ME.md.
- Keep it short enough to read before rounds.

Paper Ingest paper-ingest.md

Turn a paper into a permanent, linked knowledge node — not a throwaway summary. (The integrity-check + Zotero-mirror pro version is in the .)

skills/paper-ingest.md

# Skill: Paper Ingest

## Purpose
Turn a paper into a permanent, linked knowledge node — not a
throwaway summary.

## When to run
"Ingest this paper" + a PDF.

## Steps
1. Read _ABOUT_ME.md so you know why this paper matters to me.
2. Pull the verified citation from the PDF (authors, title, journal,
   year, DOI/PMID). Do NOT guess names — if unsure, flag "verify."
3. Write a node and save it to Literature/_.md.

## Node template
---
tags: [literature]
---
# 
**Citation:** 
**Bottom line:** 
**Methods:** 
**Why it matters to me:** 
**Connections:** [[link to related concepts or my own work]]
**Next:** <1 question or study this opens up>

## Rules
- Real citations only; verify against the PDF or PubMed.
- Add at least 2 [[wiki-links]] so the node joins the graph.

Presentation Ingest presentation-ingest.md

Turn a talk into a structured node — capture the mental model, not just bullets.

skills/presentation-ingest.md

# Skill: Presentation Ingest

## Purpose
Turn a talk (PDF or slides) into a structured talk node I can keep.

## When to run
"Ingest this talk" + a PDF/PPTX.

## Steps
1. Read _ABOUT_ME.md for relevance.
2. Extract the structure of the talk.
3. Save to Talks/.md.

## Node template
---
tags: [talk]
---
#  — 
**Thesis:** 
**Framework / mental model:** 
**Key takeaways:** <3-5 bullets>
**Figures:** 
**References worth chasing:** 
**How it connects to my work:** [[wiki-links]] to my interests
**Action for me:** 

## Rules
- Capture the *mental model*, not just bullet points.
- Add [[wiki-links]] so the talk joins the graph.

Two more projects to build

Beyond the three starters, two high-leverage builds — paste either as a single message in Cowork, pointed at your My-OS/ folder. The second needs the .

research-identity — find your throughline

Read my CV and every paper in this folder. Then write research-identity.md:
- my core themes and the methodological signature across my work
- the throughline I might be underselling
- 3 concrete directions that extend it
Cite which file each point comes from. Save it to my folder.

literature-graph — grow the vault from PubMed

Using the PubMed connector, find the 5 most important recent papers on
[my topic]. For each, write a markdown note with citation + PMID, the key
finding in 2 sentences, why it matters to me, and [[wiki-links]] to related
concepts. Save each as its own file in my vault's Literature/ folder.

Write your own

A skill is just a Markdown file with four parts: Purpose, When to run, Steps, and Rules. Take a workflow you repeat — a discharge-summary structure, a journal-club teardown, a grant-aim critique — write down exactly how you do it on your best day, and add a "never invent facts; cite the source" rule. That's a skill. The rest is reuse.

✅

Done when… at least one skill file sits in My-OS/skills/ and the agent runs it on command, producing the same structured artifact each time.

Where this connects →

Stage 10 · At Scale (Rung 6)

What a mature OS does for a surgeon-scientist.

What this is

Rung 6 is just every earlier rung, accumulated and wired together over a year: many agents + a skill library + a linked vault + connectors, across machines. Nothing new to learn — only more of the same, compounding.

Why a surgeon-scientist wants it

The mature version coordinates the whole scholarly enterprise so the routine parts run themselves and your attention goes to the science.

Tier Earned over time · the same ideas, accumulated

The capabilities it coordinates

Described as capabilities, not contents — your OS holds your world; this is the shape of what it can do:

📝 Manuscripts

Drafts, figure legends, and revisions coordinated across a paper's whole folder — with every reference traceable.

🔬 Grant-citation integrity

Every citation in an application resolved, retraction-checked, and overclaim-scanned before it goes out — the LitGuard pattern at portfolio scale.

📋 IRB & renewals

Renewal windows, continuing reviews, and personnel updates tracked so deadlines surface before they bite.

🎤 Presentation prep

Talks built from your own ingested nodes — thesis, figures, and the mental model, reused instead of rebuilt.

📚 Literature surveillance

A standing sweep of new papers in your areas, each landing as a verified node in the graph — never re-read from scratch.

🤝 Team context across machines

Shared, linked context so the same project state travels with you between machines and collaborators.

How it's built: many agents (each with a job), a library of skills (your workflows, encoded), and a single linked vault (the memory) — exactly the pieces on the other tabs, just more of them, wired together. You don't leap here; you climb here, one rung at a time.

Mine took months of iteration. Yours starts with one Project — and every rung after it pays for the next.

🔒

The boundaries scale too: still no patient data through a personal account, still a human review before anything ships, still "ask before irreversible." Capability raises the stakes on good hygiene, it doesn't relax them.

Where this connects →

Stage 11 · Reference

FAQ, glossary, pricing, privacy — always here.

The reference desk for the whole console: what it costs, how your data is handled, the alternatives, the words, and what the agent means when it says "terminal."

Your first step — small enough that you'll actually do it

Tonight · 5 min · free

Seed a Project

Make a My OS Project with your CV + goals, paste in the custom instructions, and ask it what to focus on this year. Feel it answer as someone who knows you.

This weekend · free

See your first graph

Install Obsidian, point it at your My-OS/ folder, ingest one paper, and open Graph View. Watch the first link appear.

The keen ones · paid

Run a real skill

Set up Cowork, drop in the three starter skills, and run your first Chief-of-Staff briefing on your own folder.

Q&A

The questions everyone actually asks.

Privacy, protecting your work, cost, and the alternatives — answered straight.

If I upload my CV, does it automatically go to Anthropic to train its models?

No — not automatically. For consumer plans (Free, Pro, Max), Anthropic uses your conversations — including files you upload — to improve its models only if you turn on the model-improvement setting in your Privacy Settings (plus a separate carve-out for conversations flagged for safety review). Leave that setting off and your chats and uploads aren't used for training.

A few specifics worth knowing: files reached through a connector (like Google Drive) aren't included unless you copy them into the chat; Incognito chats — ones Claude never saves — are never used for training; and when data is used it's de-identified (de-linked from your account) and may be kept in that form for up to 5 years. Anthropic says it doesn't sell your data and Claude is ad-free. If a document feels sensitive, keep the setting off or use an Incognito chat.

Source: Anthropic Privacy Center — "Is my data used for model training?" · settings: Privacy Settings

How do I protect my work?

No patient information, ever. A personal account isn't HIPAA-covered (no BAA) — use only your own scholarly materials, never patient data or institutional systems. Clinical/PHI work needs an institution-approved tool.
Set your training preference. Turn the model-improvement setting off if you'd rather your chats never be used, and use Incognito chats for sensitive drafts.
Know your plan. On Team and Enterprise plans, conversations aren't used for training by default; consumer plans put that choice in your hands.
Keep your originals. Your OS works from copies — your source files stay yours, in your own folder.
Treat the personal statement as sensitive. If unsure, use a short "career snapshot" instead, or do that part on a paid plan with training off.
Never paste secrets. No passwords, tokens, or anything you wouldn't want stored in a conversation.

How much will this cost?

The personal-OS core is free. A Project seeded with your CV and goals, Memory, and Obsidian all cost nothing — Free includes up to five Projects, which is plenty. You only pay when you want the agentic workspace:

Plan	Price	What you get
Free	$0	Chat, web search, file creation, Memory, and up to 5 Projects. The whole personal-OS core + Obsidian.
Pro	~$17/mo annual ($20 monthly)	Adds Cowork, Claude Code, Claude Design, unlimited Projects, and more usage.
Max	from $100/mo	5× or 20× the usage of Pro, higher limits, priority access — for heavy daily users.

Obsidian is free. Cowork is currently a paid research-preview feature, so it needs Pro or higher. Bottom line: you can build and feel the whole idea for $0; a paid plan is only for the hands-on agentic parts.

Prices as of June 2026 (US) and change often — check the live page.

Source: claude.com/pricing

What are the alternatives?

Everything on this page — memory, files, skills, a graph — is a concept, not a Claude feature. It transfers to any capable assistant. The main options today:

Tool	Free?	Paid (headline)	Notes & agentic equivalent
Claude (Anthropic)	Yes	Pro ~$17–20 · Max $100+	This page. Agentic: Cowork (desktop) & Claude Code (terminal).
ChatGPT (OpenAI)	Yes	Go $8 · Plus $20 · Pro $200	Most widely used. Agentic: Atlas (browser) & Codex (coding). Trains on consumer chats by default unless you opt out.
Gemini (Google)	Yes	AI Pro $19.99 · Ultra $99.99–199.99	Deep Google Workspace integration. Agentic: Antigravity. "Keep Activity" is on by default; can be turned off.
Copilot (Microsoft)	Yes	~$20/mo or in Microsoft 365	Embedded in Windows + Office (Word, Excel, Outlook).
Local / open-source	Yes	$0 (your hardware)	Run open models (e.g. Llama via Ollama) fully on your machine — offline, nothing leaves your computer. You self-host; no managed agent workspace.

If maximum privacy matters most, a local model is the strongest answer — no cloud, no subscription. If integration with your existing tools matters most, the big three each lean into their own ecosystem.

Prices and product names as of June 2026 and change frequently.

Sources: claude.com · openai.com · google.com · microsoft.com

I'm not technical. Is this going to be over my head?

No code required for the core. A Project is point-and-click; Obsidian is "open a folder." Cowork exists precisely so non-developers get the agentic workspace without a terminal — Claude Code is the terminal version for the technical crowd. If you can keep files in a folder, you can do this.

Will this take over my life?

It shouldn't, and it shouldn't try to. The point is the opposite — encode your best workflow once so you don't rebuild it every time. Tonight's step is five minutes. Add a rung only when the last one is already paying you back. Mine took months of iteration; yours starts with one Project.

Under the hood

The moving parts, in plain English.

You don't need any of this to start. But when the agent says it "wrote a Python script" or asks you to "open a terminal," here's what it means — and why it bothers.

A terminal (command line)

What: a plain text window where you type commands straight to your computer. Why: it's how developer tools like Git and Claude Code are run — no buttons, just commands. (On a Mac it's "Terminal"; on Windows, "PowerShell.")

Bash / a shell

What: the language the terminal speaks — cd to move into a folder, ls to list it, run a program by name. Why: it chains small commands into one action. (Windows' version is PowerShell.)

A script

What: a saved list of steps the computer runs top to bottom. Why: write it once, re-run it forever — automation you can trust to do the same thing every time.

A Python script

What: a script written in Python, a readable, beginner-friendly language. Why: computers are perfect at exact, repetitive jobs — counting, renaming, checking PMIDs, crunching stats. The agent writes Python for anything that must be exact, where guessing isn't allowed.

Git & a "repo"

What: a time machine for a folder — every change saved and reversible. A "repo" is one project it's tracking. Why: nothing is ever lost, and you can always roll back a mistake.

Node.js & npm

What: Node runs JavaScript outside a browser; npm is its app store. Why: Claude Code and most connectors are built on Node — it's the plumbing they need to run.

An API

What: a doorway one program uses to talk to another. Why: it's how a connector fetches your data — PubMed's API returns papers, Zotero's Web API adds references.

Markdown

What: plain text with light formatting — # heading, **bold**, [[links]]. Why: it's what your notes and skills are written in — simple, future-proof, readable by both you and the agent.

A CLI

What: a "command-line interface" — a tool you run by typing instead of clicking. Why: Claude Code is a CLI; once you're comfortable it's faster and fully scriptable.

An MCP / connector

What: the standard "plug" that lets an agent use an outside tool. Why: it's how the agent gets hands — files, PubMed, your calendar. (More in .)

The throughline: the agent reaches for a script whenever a job must be exact and repeatable, and for plain language whenever a job needs judgment. Knowing which is which is most of the craft.

Glossary

Fifteen words, plain English.

LLM: Large language model — an AI trained on huge amounts of text to predict what comes next. The engine inside Claude, ChatGPT, and Gemini.
Token: The small chunk text is split into before a model reads it — roughly ¾ of a word. Cost and limits are counted in tokens.
Context window: How many tokens a model can hold in mind at once — its working memory, or the size of its desk.
Model: One specific AI you can pick — e.g. a bigger, smarter one for hard tasks or a smaller, faster one for quick jobs.
Prompt: What you type in — the instruction or question the model responds to.
Agent: An LLM given a goal, tools, and permission to loop — so it takes actions and finishes a task instead of just answering.
Project: A chat plus persistent files and custom instructions. The agent reads them every time — its first real memory.
Memory: Facts the assistant carries forward across chats, so you stop re-explaining yourself.
Cowork: An agentic desktop app for non-developers: a real workspace where the agent reads folders, runs skills, and creates files.
Claude Code: The same agentic power in a terminal — the version for people who live in a command line.
Skill: Your best workflow written down once, so the agent runs it the same high-quality way every time. A care pathway for cognitive work.
Vault: A folder of markdown notes that Obsidian treats as one connected knowledge base.
Wiki-link: The [[double-bracket]] link between two notes — you telling your second brain that two ideas relate.
Node: One note in the graph — a paper, a talk, a person. The more it's linked, the more central it becomes.
Connector: A bridge that lets the agent reach an outside source — PubMed, your Drive, your calendar — and pull it into your system.

Privacy & PHI

The one rule that never moves.

⛔

No patient information of any kind. A personal account has no institutional data agreement (no BAA), so this is for your own scholarly materials — CV, your published papers, public data — never patient data or anything pulled from your institution's systems. Clinical or PHI work belongs in an institution-approved, BAA-covered tool. Good AI hygiene is part of the lesson.

And never paste a password, an API key, or any secret into a chat — anywhere on this page where a key or ID appears, it's a placeholder (<your-key>, <your-userID>). Your real values live in your password manager and are handed to the tool when it asks — never typed into a conversation or committed to a repo.

Jump back →