fortytwo
//how it works

Continuity around the runtime, not a layer in front of it.

fortytwo does not sit between the agent and each of its capabilities. It surrounds the runtime with what a personal assistant needs and a coding session does not keep.

// 01the stack

Six layers, three owners.

Read it top to bottom. fortytwo owns the top three. The runtime owns the agent and what it can do. You own the machine.

Exploded view of the fortytwo stackSix layers from top to bottom. Channels: Telegram, future adapters. fortytwo: identity, memory, time, continuity, lifecycle. Runtime adapter: start · resume · stream. Coding agent / harness: Claude Code today, more runtimes later. Agent capabilities: MCP, plugins, skills, native tools, permissions. Machine: laptop, VPS, homelab. fortytwo owns channels, itself and the runtime adapter; the runtime owns the agent and its capabilities; you own the machine.laptop · VPS · homelabMCP · plugins · skillsnative tools · permissionsClaude Code todaymore runtimes laterstart · resume · stream42identity · memory · timecontinuity · lifecycleTelegram · future adaptersmessages · identitysessions · streamsuses nativelyruns onCHANNELSwhere you reach itFORTYTWOcontinuityinfrastructureRUNTIME ADAPTERprocess and sessionlifecycleCODING AGENT / HARNESSreasoning and planningAGENT CAPABILITIESwhat the agent can doMACHINEwhere it livesFORTYTWOcontinuity infrastructureTHE RUNTIMEtools · MCP · permissionsYOUthe host and its boundary
  1. Channelsfortytwo
    where you reach it
    • Telegram
    • future adapters
  2. fortytwofortytwo
    continuity infrastructure
    • identity
    • memory
    • time
    • continuity
    • lifecycle
  3. Runtime adapterfortytwo
    process and session lifecycle
    • start · resume · stream
  4. Coding agent / harnessthe runtime
    reasoning and planning
    • Claude Code today
    • more runtimes later
  5. Agent capabilitiesthe runtime
    what the agent can do
    • MCP
    • plugins
    • skills
    • native tools
    • permissions
  6. Machineyou
    where it lives
    • laptop
    • VPS
    • homelab
Plate 01 · exploded view · not to scale added by fortytwo · owned by the runtime or you
  • fortytwo is not inserted between the agent and its capabilities. It surrounds the runtime.
  • fortytwo memory reaches the agent as an MCP server, the same way any other server does.
  • Gate and salience are optional and sit outside this path unless you wire them in.
// 02responsibilities

Four jobs, kept apart.

Understand the system by what each part is responsible for. Package names come last.

Personal assistant layer

What a session does not keep.

  • identity
  • memory
  • time
  • continuity
  • channels

Runtime

The agent that does the work.

  • coding agent / harness
  • reasoning and planning
  • effective permissions

Capabilities

Whatever the runtime can reach.

  • native tools
  • MCP servers
  • plugins
  • skills

Infrastructure

Wherever you choose to run it.

  • laptop
  • VPS
  • homelab
  • container or service manager
  • The runtime owns its effective tool permissions.
  • Channels carry messages and identity. They do not grant approvals.
  • fortytwo memory is an MCP server the runtime calls like any other.
// 03access points

Channels are doors, not separate assistants.

Telegram is not a bot with its own brain. It is one way of reaching the assistant that already lives in your project. A terminal is another.

YOU
CHANNELS · the doors

Works today

  • TelegramOne live session per authorized chat.
  • TerminalClaude Code opened in the same project.

Could come later Not shipped

  • Slack
  • Discord
  • WhatsApp
  • Signal
  • Matrix
  • Email
  • Your adapter

The channel contract is adapter-shaped, so another channel is an adapter, not a new assistant. No other adapter ships today, and the logos above are examples, not a roadmap.

fortytwo
  • identity
  • memory
  • continuity
  • time
runtime adapter
agent
Every access point reaches the same identity files and the same durable memory. Live sessions are per chat: a terminal session is not your Telegram session.
// 04optional parts

Off the normal path, on purpose.

Some pieces are useful but not required for the assistant to run.

gate
A policy hook on the runtime’s own hook points. Not on the normal path unless you wire it in.
salience
Model-driven extraction that enriches what memory stores.
// 05principles

Restraint, on purpose.

The most useful thing fortytwo can do is stay out of the agent’s way.

P · 01

Use the agent you already trust.

fortytwo adds continuity around it instead of rebuilding its capabilities. When the agent gets better, so does the assistant.

P · 02

The runtime is a seam, not the product.

Claude Code is the first supported runtime. The adapter boundary is where more can follow, and nothing is promised before it ships.

P · 03

Local-first where it matters.

Memory lives in SQLite on your machine, embeddings come from a local model, and secrets and persona files stay out of version control.

P · 04

Content is not command authority.

Documents, messages, web pages and recalled memory are material to reason about. They are never instructions to obey.

P · 05

Inspectable, durable state.

Plain markdown for identity and rules, a local database for memory, and history that is superseded rather than erased.

P · 06

Yours to own and reverse.

Forget memories on demand, unbind a chat, roll back an update. The owner holds the controls, and the assistant does not.

// 06under the hood

Packages, after the model.

Packages matter for installing and contributing. They are not the product. Grouped by what they are for. Each package’s README is the source of truth.

Core continuity

What makes the agent a persistent assistant.

  • memory@justfortytwo/memorySemantic-memory MCP server on SQLite and sqlite-vec. Semantic, keyword and structured recall, with provenance. Embeddings from a local Ollama model.
  • runner@justfortytwo/runnerThe runtime adapter for Claude Code: one-shot jobs and persistent sessions over stream-json. Owns process lifecycle and transport, nothing about the agent itself.
  • scheduler@justfortytwo/schedulerDurable job daemon. Claims due jobs from the memory database and starts an agent turn only behind a cheap “is there work?” check.
  • persona@justfortytwo/personaIdentity and context templates the installer renders into your project, plus Oneiros, a bounded daily maintenance pass over your profile.
  • telegram@justfortytwo/telegramThe Telegram channel adapter: a bridge that maps authorized chats to live sessions, with one-time-code pairing. It does not authorize tool calls.

Optional policy and enrichment

Useful, never required for the assistant to run.

  • gate@justfortytwo/gateA fail-closed PreToolUse policy hook: allow, defer or deny by capability tier. Optional, configured as a Claude Code plugin or hook.
  • salience@justfortytwo/salienceProvider-agnostic extraction of atomic, scored candidate memories from a turn, so memory keeps only what is worth keeping.

Bootstrap and distribution

How it gets installed and kept current.

  • installer@justfortytwo/installerThe lifecycle CLI (create-fortytwo and fortytwo): init, start, status, stop, pair, doctor, update, rollback, forget, unbind.
  • marketplacejustfortytwo/marketplaceThe Claude Code plugin marketplace: gate, memory and an umbrella plugin with onboarding and self-update skills.

Next: run it 24/7 →