Kernl

The memory layer your AI has been missing.

One self-hosted server that gives any LLM your whole life — tasks, email, finance, contacts, calendar — plus a fleet of agents that actually get work done. Private by default.

Quick start · Why Kernl · Features · MCP integration · Discussions

Your AI is brilliant — and amnesiac.

Every conversation starts from zero. Your LLM can't see your tasks, read your inbox, check your budget, or remember what you told it yesterday. And the cloud "AI assistants" that promise to fix that? They want your entire life uploaded to their servers.

Kernl fixes both.

Related MCP server: mnemory

What is Kernl?

Kernl is a self-hosted server that plugs your real life into any LLM through the Model Context Protocol (MCP). One endpoint exposes 103 tools out of the box — rising past 290 as you enable more of the 71 bundled modules: tasks, contacts, email, finance, calendar, notes, health, shopping, travel and more — to Claude, Cursor, or any MCP client.

Then it goes past a data bridge: Kernl runs agents — autonomous teams (it calls them offices) that work in loops, call your tools, and finish jobs while you're away.

Everything runs on your machine. Your data never leaves the box.

💬 Talk to your life

Point your AI at Kernl and ask it things it could never do before:

💸 "Did rent clear, and how much did I spend on food this month?" — reads your finance module.

📥 "Triage my inbox and draft replies to anything urgent." — reads your email, writes the drafts.

✅ "What's overdue, and what's due this week?" — straight from your real tasks + calendar.

🤖 "Spin up the dev office and clear the next three backlog items." — launches an agent team that works on its own.

Real data. Real actions. On your machine — not in someone else's cloud.

🎬 See it in action

Kernl ships a live 3D view of your agent teams — you watch them move between desks and pick up work as it happens. It is at /agents-flow once you are running, which the quick start below gets you to in about two minutes.

⚡ Quick start

Zero config. One command. A full stack in ~2 minutes:

git clone https://github.com/fastslack/kernl.git
cd kernl
docker compose up -d --build

# Kernl generates an API token on first boot. Grab it:
docker compose exec kernel cat /app/data/.kernel-auth-token

→ Dashboard at http://localhost:3086 · MCP endpoint at http://localhost:3086/mcp

Paste that token once into the dashboard's login screen and you're in — it's kept in your browser and reused for every request. To pin your own instead, set KERNEL_AUTH_TOKEN (openssl rand -hex 32) in .env before the first up.

No host paths, no accounts, nothing to sign up for. First run walks you through a four-step setup, and one of those steps is picking an LLM — a cloud key, or a local model through LM Studio or Ollama if you would rather nothing left the machine at all. The kernel waits for that choice before serving the rest of the API, so the dashboard cannot hand you a screen whose every button fails. The graph brain (Neo4j) and key-free web search come bundled.

🔥 Why Kernl

⚔️ Kernl vs. the usual options

🧩 What's inside

Your life, addressable by your AI — tasks & projects, contacts/CRM, reminders, email (IMAP/SMTP), finance & budgets, calendar, notes, goals, health & training, shopping, travel, documents… 60+ modules, every one exposed as MCP tools.

A fleet of agents — cooperating agents with chains, schedules and their own workspaces. Package a whole team as an installable .kernl office, and watch them work in a live 3D office view.

Pluggable everything

• LLM providers — Claude, OpenAI, Grok, LM Studio (local), and more via extensions.

• Sandbox drivers — run agent code in Docker, CubeSandbox, or your own driver.

• Channels — WhatsApp, Telegram, Slack, email, Mattermost and webchat on one notification bus.

Graph intelligence — optional Neo4j + GDS for cross-module relationship analysis.

🔌 MCP integration

Kernl speaks MCP over stdio and Streamable HTTP at the same time, so every client reaches the same tools.

{
  "mcpServers": {
    "kernl": {
      "command": "bun",
      "args": ["run", "bin/mcp-server.ts"],
      "cwd": "/absolute/path/to/kernl/services/kernel"
    }
  }
}

The MCP HTTP transport is at http://localhost:3086/mcp by default (the official Streamable HTTP spec).

🛠️ Build your own

An extension is a folder (or a packaged .kernl) with a manifest.json plus any of: a backend module (new MCP tools + HTTP routes), agents & offices, agent-scoped skills, a theme, a channel, or a sandbox driver.

Keep operator-specific material — named agents, your WhatsApp, regional scrapers — private under services/kernel/assets/personal-agents/ (gitignored, ideal for a private submodule).

Full guide → docs/architecture/extension-points.md

📦 More install options

Adds the mtwRequest Rust server, the WhatsApp bridge, and host-coupled mounts (so on-host claude_code agents can edit your sibling repos). Needs a few host paths in .env:

git clone https://github.com/fastslack/kernl.git
cd kernl
cp .env.example .env
$EDITOR .env   # set HOST_HOME, HOST_KERNEL_ROOT, HOST_PROJECTS_ROOT,
               # KERNEL_REQUEST_SRC, KERNEL_WHATSAPP_BRIDGE_SRC
docker compose -f docker-compose.full.yml up -d --build

git clone https://github.com/fastslack/kernl.git
cd kernl
bun install --cwd services/kernel   # requires bun >= 1.3
cp .env.example .env
bun run dev                # stdio MCP + HTTP router (delega a services/kernel)

Requirements

• Bun ≥ 1.3 (primary runtime) or Node ≥ 20.

• Docker + Compose (recommended — unlocks the full stack).

• Neo4j 5.x + GDS (optional; Compose starts one for you; Kernl degrades gracefully without it).

Configuration

Everything is environment-driven, and the quick start needs none of it — docker compose up boots with working defaults. Copy .env.example to .env only when you want to override something.

Two secrets are generated and persisted on first boot if you don't set them:

The host-path variables (HOST_HOME, HOST_KERNEL_ROOT, HOST_PROJECTS_ROOT) belong to the full stack in docker-compose.full.yml, not the default one. Everything else — LLM keys, Neo4j creds, feature toggles — is documented inline in .env.example.

Scripts

Known limitations

Worth knowing before you commit your life to it. None of these are secret — we'd rather you read them here than discover them at an awkward moment.

• Single user. One kernel, one person. There is user and password infrastructure inside, but no per-user data isolation: everyone who has the API token sees everything. Give each person their own instance; don't share one across a team. (docs/MULTI_USER.md)

• No auto-update. Kernl doesn't check for new versions or update itself. Watch releases if you want to know when something ships.

• Installers are unsigned. macOS needs right-click → Open the first time, Windows needs "More info → Run anyway". The signing pipeline is wired but the certificates aren't bought yet. Docker and source installs are unaffected.

• Back it up yourself, and check the exit code. backup.sh is solid and verifies its own output, but nothing runs it for you. See docs/DEPLOYMENT.md.

• Neo4j is hungry. The bundled graph wants ~1–2 GB of RAM on its own. On a small VPS, run the stack without it — Kernl degrades gracefully.

• No telemetry, which cuts both ways. Nothing phones home, so nothing tells us when your install breaks. Bug reports are the only signal we get.

Documentation

• docs/GETTING_STARTED.md — first-run walkthrough

• docs/ARCHITECTURE-MAP.md — contributor map · docs/ARCHITECTURE.md — full system guide

• docs/API_DOCS.md — HTTP + MCP surface reference

• docs/DEPLOYMENT.md — production deploys

• docs/CONTRIBUTING.md · docs/SECURITY.md · docs/PRIVACY.md

⭐ Contributing & community

Kernl is Apache-2.0 and built in the open. Star the repo if it's useful, open an issue for bugs and ideas, and say hi in Discussions. Contributions welcome — see docs/CONTRIBUTING.md.

License & credits

Created and maintained by Matias Aguirre — a Matware project. See AUTHORS and NOTICE.

Released under the Apache License 2.0 — fork it, build commercial plugins on top, redistribute, modify. © 2026 Matware.