fortytwo
// 01fortytwo

Your coding agent is already powerful.

fortytwo makes it personal, persistent, and always there.

fortytwo adds memory, identity, continuity, time and channels around the agent runtime you already trust — without replacing its tools, permissions or integrations.

Run it 24/7 →

Claude Code is the first supported runtime. More can follow.

// 02the boundary

Don’t reinvent the agent.

Coding agents already reason, plan and act. fortytwo does not compete with that. It supplies what a long-lived personal assistant needs and a coding session does not give you.

The agent already knows how to

  • think and reason
  • plan
  • use tools
  • call MCP servers
  • run plugins and skills
  • browse and use a computer
  • write code
  • ask for permission
  • perform actions

fortytwo makes it possible to

  • remember you
  • stay the same assistant across sessions
  • stay reachable through persistent channels
  • wake up later
  • carry durable context forward
  • keep a personal identity and continuity

fortytwo should inherit improvements from the underlying agent, not compete with them.

MCP servers, native integrations, plugins, skills and external workflow systems stay first-class parts of the agent’s own ecosystem. fortytwo does not rebuild them or sit in front of them.

// 03what it adds

Your agent already has tools. fortytwo gives it continuity.

A coding session ends. An assistant should not. These are the pieces that carry across, and they are continuity, not new intelligence.

// 01

Memory

Durable personal recall, kept on your machine. Memories carry provenance, can be corrected without erasing history, and are found by meaning or by keyword.

// 02

Identity

A coherent assistant that belongs to the installation: a name, a voice, owner context and house rules, rendered into plain files you can read and edit.

// 03

Continuity

Sessions and channels are access points to the same assistant, not disposable chats. A conversation can resume after a restart.

// 04

Time

Durable scheduling and proactive work. The assistant can have something to do later, not only something to answer now.

// 05

Channels

Use it where you already are. Telegram is the first channel; the boundary is a channel adapter with its own pairing, not a Telegram bot.

// 06

Your ecosystem

MCP, plugins, skills and the runtime’s native permissions remain the agent’s. Whatever the agent learns to do, the assistant can do.

// 04session to presence

From a session to a presence.

A coding agent usually feels like something you launch. Put fortytwo on a machine that stays online and the same kind of agent can stay reachable.

A session

A coding agent on a laptop

  1. open a terminal
  2. start the agent
  3. work
  4. close the machine
  5. gone until next time
A presence

fortytwo on a host that stays online

fortytwo stays available
  • identity persists
  • memory persists
  • the scheduler keeps time
  • channels stay reachable
  • the agent runtime runs when there is work

24/7 does not mean the model is running 24/7.

It means the assistant infrastructure is available 24/7. The model is invoked when there is a turn to take: a message from you, or a job that is due.

Run it 24/7 →

// 05architecture

Around the agent, not in front of it.

fortytwo surrounds the runtime. Claude Code is the first supported runtime. More can follow. Everything the agent can do natively, it still does natively.

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.42CHANNELSFORTYTWORUNTIME ADAPTERCODING AGENT / HARNESSAGENT CAPABILITIESMACHINEFORTYTWOTHE RUNTIMEYOU
  1. Channelsfortytwo
    where you reach it
  2. fortytwofortytwo
    continuity infrastructure
  3. Runtime adapterfortytwo
    process and session lifecycle
  4. Coding agent / harnessthe runtime
    reasoning and planning
  5. Agent capabilitiesthe runtime
    what the agent can do
  6. Machineyou
    where it lives
Plate 01 · exploded view · not to scale added by fortytwo · owned by the runtime or you

Explore how it works →

// 06go deeper

Four short pages, no maze.

Package-level detail lives in the GitHub repositories and the design docs.

// 07quick start
three commands
# in a new, empty directory
$ npx @justfortytwo/installer init
$ fortytwo start # foreground · Ctrl+C stops it
$ fortytwo pair # second terminal · prints a code
# then, in Telegram
> /login <code>
> hello

Open Telegram. Say hello.

init installs the engine packages, captures who the assistant is and who it serves, wires memory, and renders the persona into plain files. pair issues a one-time code; until a chat redeems it, the bot ignores everyone.

Needs Node ≥ 20 · Claude Code · Ollama for the local embedder · a Telegram bot token in .env.

STAY CALM

The answer is 42.
The hard part is knowing the right question.