alive

                 █████╗  ██╗     ██╗██╗   ██╗███████╗
                ██╔══██╗ ██║     ██║██║   ██║██╔════╝
                ███████║ ██║     ██║██║   ██║█████╗
                ██╔══██║ ██║     ██║╚██╗ ██╔╝██╔══╝
                ██║  ██║ ███████╗██║ ╚████╔╝ ███████╗
                ╚═╝  ╚═╝ ╚══════╝╚═╝  ╚═══╝  ╚══════╝

claude plugin install alive@alivecontext

Or from the Claude Code UI: /plugins → add marketplace alivecontext/alive → install alive

How It Works

Open Claude Code at your ~/world. The runtime is already loaded.

ALIVE structures your context into plain files on your machine. Agents read them at session start and save what matters at session end. Everything in between — the decisions, the research, the people, the knowledge — gets structure instead of dying with the session.

Orient. Before you say a word, the runtime has already oriented the agent — a lightweight index of your world, your preferences, and the behavioural rules that make the agent yours. When you load a walnut — a venture, an experiment, a person, a life area — three files give the agent its identity, current state, and standing knowledge. No re-explaining. No pasting context. The agent knows what you're building, who's involved, and what happened last time.

Work. Every AI session is a context event. You're injecting context — files, transcripts, research, screenshots. You're generating context — decisions, architecture choices, domain knowledge. You're discovering context — connections between people, patterns across projects, insights that only surface mid-conversation. Right now, all of that is ephemeral. It dies when the window closes. ALIVE catches it as it happens.

╭─ 🐿️ +4 stash (8)
│   Decided: React Native for mobile app              → my-startup
│   Task: Chase Jake for API specs by Friday           → my-startup
│   Note: Jake prefers async comms, hates standups     → [[jake-chen]]
│   Action: Connected ElevenLabs API for voiceover     → my-startup
│   → drop?
╰─

Decisions route to the log. Tasks route to the queue. People updates route to their person walnut. Actions get tracked. Nothing gets lost.

Save. When you checkpoint, everything routes to where it belongs — decisions to the log, tasks to the queue, knowledge to insights, people updates to their own files. External content gets captured into bundles. Scripts compute a fresh snapshot. The ephemeral becomes structural.

Compound. Next session inherits everything the last one produced. And the one before that. Context accumulates. Sessions build on each other instead of starting from zero.

Two Units

Walnut — unit of context

Each meaningful thing in your life gets a walnut — your startup, your people, your health, your side project.

A walnut has a kernel — three source files that move at different speeds:

my-startup/
  _kernel/
    key.md        → What it is (identity, people, links — rarely changes)
    log.md        → Where it's been (prepend-only, signed decisions)
    insights.md   → What it knows (evergreen domain knowledge)
    tasks.json    → What needs doing (script-operated)
    now.json      → Current state (generated on save, never hand-written)

The agent writes to source files. Scripts compute the projection. Judgment and aggregation stay separate.

Bundle — unit of work

Work gets done inside bundles. Each bundle has a goal and owns its own tasks.

# context.manifest.yaml
goal: "Ship the website from strategy deck to production"
status: prototype         # draft | prototype | published | done

Two species: outcome bundles ship a deliverable and graduate. Evergreen bundles accumulate context over time — meeting notes, research, reference material.

Bundles are shareable — your workflow becomes a context product anyone can install.

The Runtime

The squirrel is the agent runtime — rules, hooks, skills, and policies that any AI agent inhabits when working inside your world. Why squirrel? 🐿️ Squirrels scatter-hoard — bury context now, retrieve by value later. That's the mechanic.

┌─────────────────────────────────────────────────┐
│          squirrel.core@3.0 runtime               │
│                                                  │
│  ┌───────────┐   ┌───────────┐   ┌───────────┐  │
│  │   Rules   │   │   Skills  │   │   Hooks   │  │
│  │ 6 files   │   │ 15 skills │   │ 13 hooks  │  │
│  └───────────┘   └───────────┘   └───────────┘  │
│                                                  │
│  ┌─────────────────────────────────────────────┐ │
│  │              PERSONA LAYER                  │ │
│  │   Named squirrel · voice · instincts        │ │
│  └─────────────────────────────────────────────┘ │
│                                                  │
│  ┌─────────────────────────────────────────────┐ │
│  │           AGENT INSTANCE                    │ │
│  │   Claude, GPT, local — interchangeable      │ │
│  └─────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────┤
│              YOUR WORLD  (v3)                    │
│                                                  │
│  Archive · Life · Inbox · Ventures · Experiments │
│     └── walnuts ──┐                              │
│                   ├── _kernel/ (identity, state)  │
│                   └── bundles  (units of work)   │
│                                                  │
│  Scripts compute projections. Agents read them.  │
│  Plain files. Your machine. Nothing phones home. │
└─────────────────────────────────────────────────┘

You name your squirrel. It persists across sessions — same identity, same context awareness, regardless of which model is running underneath. The runtime loads your world, the agent does the work, the save makes it permanent.

See your full world at session start with /alive:world. Visualise it with /alive:my-context-graph.

The ALIVE Framework

Five domains. The file system is the methodology.

01_Archive/       → A — Everything that was
02_Life/          → L — Personal foundation
03_Inbox/        → I — Buffer only — arrives, gets routed out
04_Ventures/      → V — Revenue intent
05_Experiments/   → E — Testing grounds

Session Flow

START ──→ Hook creates session, loads preferences
  │
  ▼
OPEN ──→ Read key.md → now.json → insights.md
  │       Agent is oriented. One observation.
  │
  ▼
WORK ──→ Stash in conversation. Capture to disk.
  │       Everything else waits for save.
  │
  ▼
SAVE ──→ Confirm stash → route to destinations
  │       Write log → update bundle → compute projection
  │       Stash resets. Back to WORK or EXIT.
  │
  ▼
EXIT ──→ Sign session. Final projection.

Install

claude plugin install alive@alivecontext

Requires Claude Code + Python 3. Works on macOS, Linux, Windows (WSL).

15 skills, 13 hooks, 6 rule files, templates, and a statusline.

Skills

Upgrading

claude plugin install alive@alivecontext

/alive:system-upgrade --dry-run --plan-output /tmp/upgrade-plan.txt
/alive:system-upgrade

The upgrade skill works against any prior version (v1, v2, v3.0, v3.1, v3.2). It detects what's there via content fingerprints, shows you a plan first (--dry-run), backs everything up to a versioned tarball, and migrates only what needs migrating. Multi-surface aware — if you run alive-mcp or Hermes alongside the plugin, their migrators are dispatched too. Partial-failure resume via --resume. Inspection-mode rollback via --rollback. Your old plugin keeps working — nothing breaks.

What People Are Saying