Antu is a set of skills you can use to turn raw sources into synthesized, queryable knowledge. Agents operate the vault: they ingest, recall, and maintain. You define what matters and when to persist it.
The system separates two kinds of memory:
- Operational memory — what's happening now and what was decided. Lives in
.hot/HANDOFF.md(session cache), read by the agent at every session start perAGENTS.mdinstructions. Small, fast, always loaded. - Knowledge base — what the vault knows about the world. Lives in
wiki/(synthesized pages). Large, deep, consulted on demand.
The skills work from anywhere. Installed globally, they let you recall knowledge, ingest sources, or snapshot context from any project, in any session, into a vault that lives somewhere else entirely — the vault is a target, addressed by name, not a place you need to be.
Two ways to install, depending on your agent.
- Run the skills.sh installer:
npx skills add itsmistermoon/cortex-forge- See the Supported Agents table to pick the exact flag value per agent.
Skills install unnamespaced: /antu-ingest, /antu-handoff, /antu-imprint, /antu-recall, /antu-prune, /antu-triage, /antu-setup.
This repo is also a self-hosted Claude Code plugin marketplace — one repo, one plugin.
/plugin marketplace add itsmistermoon/cortex-forge
/plugin install antu@antuSkills install namespaced: /antu:antu-ingest, /antu:antu-handoff, etc. To test a local checkout before installing, use claude --plugin-dir . from the repo root.
Run /antu-setup (or /antu:antu-setup) in your agent — from a fresh git repo or an existing vault. This skill will:
- Scaffold
wiki/and a starterAGENTS.mdif they don't exist yet (asks first — never overwrites an existing vault), detect your locale, and register the vault in~/.cortex-forge/config.yml - Verify all seven skills are actually installed, and tell you to re-run
npx skills add(or/plugin update) if any are missing - Offer to set up semantic search, with a dependency check that runs before asking
- Offer optional extras: syncing infrastructure from upstream, a stale-cache warning threshold, and post-commit git hooks for prune/reindex
- Ask which vault to set as default if more than one is registered
Six layers, each with a distinct role:
| Layer | Path | Purpose | Rule |
|---|---|---|---|
| Raw | .raw/ |
Primary sources — immutable originals | Read-only |
| Wiki | wiki/ |
Secondary sources — synthesized knowledge | Agent writes and maintains |
| Hot | .hot/ |
Per-project session cache | Read on session start |
| Instructions | AGENTS.md |
Agent protocols (handoff, ingest, recall) | Read on session start |
| Meta | wiki/meta/ |
Vault metadata and guides | Agent maintains |
| Skills | skills/ |
Invocable agent skills | Extend, don't modify |
Seven skills that map to how knowledge actually moves through a system.
Sources land in .raw/: articles, PDFs, transcripts, URLs. The agent processes them and produces structured wiki pages — the step that turns perceived input into stored, queryable knowledge.
After synthesizing new pages, it scans existing wiki pages and selects those who are candidates for backward enrichment — existing concept pages, entity entries, and comparison tables that should now mention the new source but don't. An agent evaluates each candidate before any change is made.
.hot/HANDOFF.md extends working memory indefinitely across two zones: a mutable Current state (max 5 pending items, max 3 active decisions) and an append-only History. The agent reads it on session start per AGENTS.md instructions; you invoke /antu-handoff at milestones and before closing a session, carrying context forward into the next one. Works from any repo, not just the vault.
What was worth keeping from the session becomes a stable wiki page. A memory trace is what remains after an experience ends. The session closes; the knowledge stays encoded in the vault.
The agent searches the vault, retrieves relevant pages, and synthesizes a response with citations, drawn from what's been ingested or imprinted into it.
Detects orphan pages, dead links, contradictory claims, stale information. Forgetting functions as maintenance: prune removes what weakens the network deliberately, so what remains stays reliable.
On-demand deep clean of .hot/ (the active repo's session state, not the vault): retrospective PLAYBOOK.md pruning, recovering pending/fragile-context items after a foreign-suite (Kuyen) write, and validity re-checks on existing ### Pending/### Active decisions entries. Mirrors /antu-prune's pattern — a separate hygiene skill, not folded into /antu-handoff's per-session mechanics.
Registers the vault and installs global skills. Run from inside a vault directory. Run again from the same vault to deregister.
Installed via the Claude Code plugin, these are available as bare commands (bin/ is on the plugin's PATH). With the skills.sh install, run them with their path from a checkout instead, e.g. bash bin/antu-embed.sh.
antu-embed.sh— bootstrap the semantic index for a vaultsetup-vault.sh— scaffold an Obsidian vault (directories, graph colors by type, theme, community plugins) for a fresh Antu vaulttags-audit.py— audittags:usage across a vault's wiki pages (tags-audit.py <vault-path> [--write-snapshot])
| Type | Path | Purpose |
|---|---|---|
| Concept | wiki/concepts/ |
Synthesized knowledge — ideas, patterns, frameworks, lookup tables, cheat sheets |
| Entity | wiki/entities/ |
Concrete named things in the world — people, tools, orgs, services |
| Source | wiki/sources/ |
External artifact ingested — articles, docs, repos, videos, threads |
| Project | wiki/projects/ |
Active project with operational state (repo, status, domains) |
Each page follows: YAML frontmatter + compiled truth + chronological changelog.
Three behaviors are mandatory for any agent operating the vault, defined in AGENTS.md:
Handoff — before responding to the user, read .hot/HANDOFF.md and AGENTS.md. After milestones, invoke /antu-handoff to snapshot current state and append a history entry.
Ingest — when the user provides a URL, file, or uses words like "ingest" or "process", invoke /antu-ingest as the first action.
Recall — when the user asks about any topic that may exist in the vault, invoke /antu-recall as the first action. The skill returns synthesized knowledge with citations; treat that as the authoritative answer over active context, grep, or training knowledge on vault topics.
One consumption channel, identical everywhere. AGENTS.md mandates reading .hot/HANDOFF.md (hard size caps) before the first response, on every agent, with no hook wiring required. The guarantee comes from the protocol itself — unconditional, explicit, and simple enough to follow the same way across any coding agent.
State and lessons as separate artifacts. Session-end snapshots capture state — pending work, decisions, fragile context. Lessons get a dedicated path: at session end, /antu-handoff flags imprint candidates in the history entry, invoked manually with full context; at the next session start, reading .hot/HANDOFF.md surfaces that flag and the agent proposes /antu-imprint with fresh eyes. Detection happens where context is richest; the decision happens where judgment is freshest.
Memory as an audited surface. .raw/ stays immutable, keeping provenance auditable at every point. Ingestion scans foreign content for hidden Unicode, embedded payloads, and egress commands before it enters the vault. The handoff-flags → imprint-proposes step defaults to suggest, putting a human approval step between session output and anything becoming ground truth.
Failed attempts as first-class knowledge. The hot cache contract records attempted-and-failed approaches, with evidence, as a dedicated section — carrying forward what didn't work alongside what did.
Antu has a sibling project, Kuyen, built later as a from-scratch reapplication of what Antu's growth taught: minimal dependencies, no scripts, no reference docs, no multi-vault machinery — just skills. Both are "vault" suites; neither depends on the other. Pick per vault, not once for everything you do:
| Axis | Antu | Kuyen |
|---|---|---|
| Vault size / lifespan | Large, multi-session, expected to accumulate substantial knowledge over time | Small or short-lived — a scratch vault, a single project's notes |
| Feature needs | Provenance tracking, multi-vault resolution, research mode, semantic search, planned MCP integration | Ingest / query / handoff, nothing beyond that |
| Latency / dependency tolerance | Fine waiting on heavier operations for more capability | Wants near-instant operations with no external dependencies |
Conventions the two suites deliberately share (not features — just shared shape, like log entry formatting) are tracked in docs/family-conventions.md.
Skills resolve the target vault from wherever you are — no cd required. The global config at ~/.cortex-forge/config.yml maps names to a path and locale:
vaults:
personal:
path: ~/second-brain
locale: en
work:
path: ~/work-vault
locale: en
default: personalSkills resolve the vault automatically: if you're inside a registered vault → that vault; otherwise → default. You can pass an explicit vault name as the first argument to override from anywhere:
| Skill | Explicit vault arg |
|---|---|
/antu-ingest |
✅ /antu-ingest <vault-name> <url-or-file> |
/antu-recall |
✅ /antu-recall <vault-name> <query> |
/antu-handoff |
✅ /antu-handoff <vault-name> [project-name] [next: <focus>] |
/antu-imprint |
✅ /antu-imprint <vault-name> |
/antu-prune |
✅ /antu-prune <vault-name> — asks for confirmation before proceeding |
/antu-triage |
⛔ — resolves the active repo (nearest .git), not a vault |