Name: alive
Author: alivecontext

Installation

Add to your Claude Code skills directory:

# Add to your Claude Code skills
git clone https://github.com/alivecontext/alive

Security Report

Verified

Last scanned: —

{
  "status": "PASSED",
  "issues": []
}

README.md

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

Personal Context Manager for Claude Code

The agent is replaceable. The runtime is portable. The walnut is permanent.

claude plugin marketplace add alivecontext/alive
claude plugin install alive@alivecontext

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

ALIVE session demo

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 marketplace add alivecontext/alive
claude plugin install alive@alivecontext

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

15 skills, 14 declared command invocations across 5 hook event types, 6 rule files, templates, and a statusline. See the permission and side-effect declaration.

Skills

Skill	What it does
`/alive:world`	See your world — dashboard, health, routing
`/alive:load-context`	Load a walnut — identity, state, active bundle
`/alive:save`	Checkpoint — route stash, generate projections
`/alive:capture-context`	Store external content, route to bundles
`/alive:bundle`	Create, share, graduate bundles
`/alive:search-world`	Search across walnuts, bundles, people, logs
`/alive:create-walnut`	Scaffold a new walnut
`/alive:system-cleanup`	Maintenance — stale bundles, orphan files
`/alive:settings`	Preferences, permissions, voice
`/alive:session-history`	Session timeline, squirrel activity
`/alive:mine-for-context`	Deep context extraction from source material
`/alive:build-extensions`	Create skills, rules, hooks for your world
`/alive:my-context-graph`	Render the world graph
`/alive:session-context-rebuild`	Rebuild context from past sessions
`/alive:system-upgrade`	Upgrade from any previous version

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

"most cracked thing I've seen for AI in 2025."

Louka Ewington-Pitsos
_{AI Researcher · Parsewave}

"two AI systems, one context layer."

witcheer ☯︎ · _Telegram
_{Hermes integration pioneer}

"You're gonna smoke everyone with this."

Athon Millane
_{AI Researcher · VC-backed · SF}

"context quality > context quantity."

Marcus
_{original tweet}

"best thing ive ever used. this is fucked."

Caspar Tremlett
_{Brand Business Coach · Bali/Australia}

"Bro. ALIVE is legendary."

Roland Bernath
_{Growth Strategist · 6K followers}

Context as Property

Your context lives on your machine as plain files. Switch models — Claude to GPT to local — your walnuts come with you. Switch platforms — your walnuts are yours.

No cloud. No account. No vendor lock-in. Git-track it if you want version history. Or don't. Your context is your property.

Roadmap

Bundle marketplace — share and discover context products
Obsidian plugin — walnut dashboards and context graph
MCP server — read and manage walnuts from any MCP client
Hermes plugin — persistent context for autonomous agents
OpenClaw context engine — ALIVE as a context slot
Integrations registry — track every API, service, and connection across your world

A small ask

ALIVE is open source. As you use it, the plugin will surface a small invitation a handful of times — two soft inline lines and three full asks across your first sixty sessions, plus an occasional one-line nudge after /alive:save. After that it goes quiet, whether you star or not. The star is fired through your own gh CLI (browser fallback if gh isn't authenticated); nothing leaves your machine except the star itself. Silence it any time by setting github_star_ask: false in .alive/preferences.yaml.

Contributing

Open an issue · Discussions · Contributing guide

Built by Lock-in Lab · @benslockedin · MIT License

Frequently Asked Questions

What is alive?⌄

alive is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by alivecontext. Personal Context Manager for Claude Code. Your life in walnuts. It has 126 GitHub stars.

Is alive safe to use?⌄

Yes. alive passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.

How do I install alive?⌄

Clone the repository with "git clone https://github.com/alivecontext/alive" and add it to your Claude Code skills directory (see the Installation section above).

What programming language is alive written in?⌄

alive is primarily written in Python. It is open-source under alivecontext on GitHub, so you can review or fork the full source.

Are there alternatives to alive?⌄

Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh alive against similar tools.

alive