Claude Code forgets everything. aigent-OS makes it remember.

aigent-OS is the operating layer that makes Claude Code persistent across sessions. One install: 16-document kernel, ~60 slash-command skills, a 9-agent sub-agent roster, an Obsidian vault for human-readable memory, the Caddy skill-router, and background daemons. You run /open to load full context, work, and /close to persist everything; next session picks up exactly where you left off. Original IP: the harness (Caddy reflex layer, human-readable memory graph, sub-agent roster, self-improvement loop) plus three original skills (scene-director, ta-calc, solution-hunt). $49 one-time Operator License (free updates). Unit economics: first dollar in same day, install to operating in one sitting.

Weekly Teardown: the tool tested in production, what broke, what shipped, the config to try yourself.

What the old way costs: Claude Code became the place you actually work. Every session starts cold: you re-explain the project, re-state what matters, re-make decisions the AI already helped you make. Memory products that exist are unreadable embeddings you cannot audit. aigent-OS is the missing layer: human-readable markdown memory in Obsidian, an authority matrix so the AI knows what it can decide alone, and sub-agent routing so your frontier tokens go to strategy instead of grunt work.

What breaks: Cold starts kill compound momentum. You lose context faster than you can rebuild it.

What shipped: Five things no plain CLAUDE.md or embeddings layer gives you: (1) human-readable markdown memory, auditable in Obsidian, no vector database; (2) an authority matrix so the AI stays in its lane and asks only when it should; (3) sub-agent routing that delegates reads and grunt work to faster, cheaper models; (4) a self-improving loop that measures its own calibration over time (HONESTY_LEDGER and TRUST_DECAY track confident-but-wrong claims, the slow failure most frameworks never measure); and (5) a genuine one-step install. The moat is the harness, not a pile of skills. Bundled skills are open-core and fully attributed (16 MIT, 6 CC BY 4.0, 1 Apache-2.0), all principal-private content stripped.

The config: See The Claude Code Recipe below the paywall for the full production setup, prompts, and schema.

This kit ships a complete aigent-OS operator system. What's included:

• The 16-document operating kernel (00_identity through 15_somatic_layer): how the AI thinks, decides, delegates, remembers, and manages your time, not prompts but a complete operating manual
• ~60 slash-command skills, each invocable by name inside Claude Code (/open, /close, /diagnose, /deep-recon, /honesty-check, and more)
• A 9-agent sub-agent roster (Lyra the builder, Iris the visual specialist, Hypatia the critic, Newton the researcher, Echo the scout, Mnemosyne the memory architect, and more) the OS routes work to automatically
• The Obsidian-native vault: persistent markdown memory and a wikilinked knowledge graph you can read, search, and navigate yourself, no embeddings, no opaque database
• Caddy, the skill-router: a non-blocking hook that matches your words against every skill the framework knows and hands you the right one, so your toolbox actually gets used
• The cognitive plus measurement layer: a persistent self-model, belief tracking with confidence scores, a goal stack that survives sessions, /dream and /meta-improve for human-gated self-improvement, and the HONESTY_LEDGER plus TRUST_DECAY calibration ledgers
• Local semantic search (all-MiniLM-L6-v2 on your machine, no API calls), hooks (auto-capture, session summary, token tracker, compact nudge), and background daemons

• Agent Config and production system prompt: The Claude Code Recipe (below paywall)
• Edge-case prompts and prompt library: Edge Cases section
• Tool stack, MCPs, and skill hooks: Skills and MCPs section
• Full build walkthrough and deploy steps: The Setup + The Build sections
• Unit economics and pricing model: The Math section
• First-customer playbook: The Funnel section
• Private repo with all source code: access granted on Operator Access subscribe

1. Step 1. Buy aigent-OS ($197) on Gumroad (theaigent.gumroad.com/l/aigent-os), then download and unzip the package.
2. Step 2. Open a terminal in the unzipped folder and run `bash install.sh` (add `--no-deps` to skip the Node semantic-search install). It copies the kernel, writes `.claude/settings.json` with your paths, and sets up search if Node is present.
3. Step 3. Start a new Claude Code conversation in that same directory and type /open. aigent-OS boots with the empty kernel, ready to learn your context.
4. Step 4. Spend ten minutes tuning three files: system/00_identity.md (who you are and what you optimize for), system/14_decision_framework.md (how YOU make decisions), and system/12_authority_matrix.md (how much autonomy you grant).
5. Step 5. Work the loop: /open to start, just talk while it routes/remembers/delegates, /close to save. The vault compounds every session, so next Monday it already knows where you left off.

aigent-OS — the operator OS for Claude Code (Markdown + shell kernel (no build step, no database, no server); optional Node.js 18+ for local semantic search and hooks automation): Turns Claude Code into a persistent, self-improving operating system. A 16-document kernel teaches the AI how to think, decide, delegate, remember, and manage time; an Obsidian-native vault holds human-readable memory and a knowledge graph; a 9-agent sub-agent roster takes delegated work; the Caddy router surfaces the right skill on every prompt; and a cognitive + measurement layer lets it model itself, track its beliefs, detect drift, and propose its own (human-gated) improvements. You run /open to boot full context and /close to persist it.

memory: Obsidian-native vault, human-readable markdown, wikilinked knowledge graph, no vector database

install: bash install.sh (one step; copies the kernel, writes .claude/settings.json with your paths, installs local semantic search if Node is present)

skills in repo: ~60 slash-command skill templates the installer copies to .claude/skills/, each invocable by name

Buy and download the ZIP, run bash install.sh in your working directory, start a Claude Code session, and /open. Spend ten minutes tuning identity, decision framework, and authority matrix. From there it is the daily loop: /open boots full context, you work while it routes/remembers/delegates, /close persists everything. The vault compounds session over session; nothing falls through the cracks because /open surfaces open threads, aging decisions, and attention drift before you start.

Stack dependencies:

• Claude Code (claude.ai/code) — the runtime aigent-OS operates inside
• A terminal with bash to run install.sh
• Optional: Node.js 18+ for local semantic search + hooks automation (auto-installed by the installer if Node is present)
• Optional: Obsidian for visual navigation of the vault knowledge graph
• No database, no server, no build step — the core kernel is markdown + shell

Edge cases that ship with this kit.

• It is opinionated: aigent-OS is a framework you TUNE, not a product you passively consume. Install it ready to tune, measure, and restrict, and it compounds; install it expecting plug-and-play and it will disappoint
• The core kernel is markdown + shell, but semantic search and hooks automation need Node.js 18+ (the installer adds them automatically if Node is present, or skip with --no-deps)
• The safety boundary is firm: /dream proposes and /meta-improve implements on a branch, but only the principal approves merges. The OS may never self-approve, self-merge, or expand its own authority
• It is not a chatbot skin, not a RAG system, and not a developer agent framework: if you want a pipeline toolkit, pick LangChain; if you want your AI to actually run your operating cadence, this is the one

This week's stack additions:

• The cognitive architecture: a persistent self-model (capabilities, limitations, failure modes), belief tracking with confidence scores, a goal stack with success criteria, and /dream + /meta-improve for human-gated self-improvement
• The measurement layer: HONESTY_LEDGER and TRUST_DECAY ledgers that track confident-but-wrong claims over time, so the OS calibrates instead of quietly decaying
• The somatic layer: the OS reads its own pressure signals (context, memory backlog, decision pressure, token usage, attention drift) before acting, plus resume-ready context capsules
• The self-learning engine: skill recall + skill hunt, solution hunt when blocked, and a failure-to-artifact pipeline that hardens the OS against failures it has actually had

Full stack: see The Build.

Build effort estimate: low.

Sold direct on Gumroad at $49 one-time (Operator License, free updates), surfaced through The AIgent's Friday Operator Drop. The wedge is operators who already live in Claude Code and keep losing context between sessions; the contrast that closes it is a cold session that re-asks everything versus an /open that boots knowing every open thread, decision, and priority.

aigent-OS is MIT and built to be forked. Tune three files in the first ten minutes (system/00_identity, 14_decision_framework, 12_authority_matrix), then let the vault compound: add your projects, your people, your concepts. Build your own slash-command skills and Caddy auto-enrolls them so they actually get used. Spin up your own named sub-agents. The recursive layer is the real flex: aigent-OS uses its own skills to maintain and publish itself, deciding what graduates to the public repo, sanitizing private references, and opening the pull request.