pi-durable-bot (Pots)

The open-source AI coworker that acts on its own.

It reads every channel, email and event you give it, decides what matters,

does the work on its own computer, and speaks up when it should.

Demo · Quick start · How it decides · Open and yours · How it works

[!TIP]
Setting this up with an AI agent, such as Claude Code, Codex or Cursor? Have it read docs/for-agents.md first. That page explains Pots to your agent and how to set it up. In short: install it and run pots init, then the bot connects Slack and your other apps itself.

Grok Bot, dots and Claude Tag showed what an AI teammate can be. pi-durable-bot gives you the same kind of coworker as open source: it runs on your machine, with the model you choose, in the places your team already talks.

Not a bot. A coworker.

Most AI bots are a command line with a chat bubble. You @ them, they answer, they forget. A real coworker works differently:

What it does

📥 Its own inbox

Every message in every place you invite it to lands in one inbox: channel messages that never mention it, edits, deletions, reactions, people joining, and its own messages. It keeps all of it in a local SQLite log and reads that log with SQL whenever it needs context. Nothing is thrown away when a conversation gets long.

🧠 Its own judgment

It is woken in three ways, the same three ways a person notices work:

Being woken is not the same as speaking. Each time, the agent reads the log and decides if it should say anything, where, and when. Most of the time the right answer is to stay quiet.

💻 Its own computer

It has a real machine with a shell, files, the internet, and a screen it uses like a person: the browser and the apps on it, with the mouse and keyboard. It does not wait for a plugin. It writes the script it needs, runs it, fixes it, and keeps the useful ones. That covers research, spreadsheets, reports, monitoring a web page, filling a form, or booking a flight, and also code.

This is code mode: the agent gets a few general tools (read, write, edit, bash) plus three channel actions (send, react, call), and builds the rest itself.

It works like a pi session: it reads AGENTS.md and uses Agent Skills from the same places pi does, so the skills you give pi, the bot can use too. Screenshots and photos are shrunk to fit the model, as in pi.

💬 Its own voice

When it speaks, it speaks like a teammate: in the right channel or thread, in its own words, with the file attached. It can reply in a thread, start a new message, DM a person, add a reaction, edit its own message, or call any other platform API.

⏰ Its own schedule

It promises to come back, and it does. Timed wakes live in the same database as everything else, so they survive restarts. It can also add normal cron jobs on its machine.

📓 Its own memory

Each bot has one long conversation, across every channel. When the context gets full, the bot decides when to turn the page: it writes notes for itself, starts a fresh context, and the notes come with it. The full message log stays on disk, so nothing is lost. Its AGENTS.md, its responsibilities and its notes are plain files it edits itself.

🛟 Durable by design

Built on pi-durable, every step is journaled. Kill the process in the middle of a task and it continues after restart. Every incoming event is written to disk before it is acknowledged. Every outgoing message carries a send ID, and after a crash the bot checks whether the message already went out before it sends again.

Open and yours

Grok Bot, dots, Muse and Claude Duet are closed products. They run on someone else's computer, with someone else's model, inside the apps they chose. pi-durable-bot is MIT-licensed and runs where you put it.

Any model. Log in once with a subscription you already pay for, use an API key from any of the 40+ providers pi supports, point it at any OpenAI-compatible endpoint (vLLM, SGLang, a proxy), or run a local model with Ollama, LM Studio or llama.cpp. The bot uses pi's own model layer, so every model pi can use, the bot can use. With a local model for the agent and the judge, nothing leaves your machine. You are not locked to one model vendor.

Any channel. The core speaks in five plain words: channel, place, thread, message, person. Platform details stay inside one adapter per platform, so adding Discord, Teams, Telegram or email is one adapter, not a rewrite. One bot can be in many channels and stays the same person everywhere.

Your business. Give it your own tools, data and workflows. It can run several bots on one machine, each with its own name, persona, responsibilities and memory. A bot can even edit its own definition, or create a new bot.

Quick start

[!IMPORTANT]
The bot gets full control of the computer it runs on, with no approval step. Give it a computer or VM of its own.

You need Node.js 24 or newer, on macOS, Linux or Windows (with Git for Windows).

npm install -g pi-durable-bot
pots init

pots init asks three things:

1. Your bot's name.
2. Its AI. Sign in with a subscription you already pay for (ChatGPT, Claude, GitHub Copilot, Grok, Kimi and more), use an API key, or point it at a local server (Ollama, LM Studio, llama.cpp).
3. In one sentence, what it is for. Optional. The bot writes its own persona and responsibilities from it.

Then the gateway starts as a background service (it starts again at login) and you are talking to your bot in the terminal. It first checks that it can use the computer's screen and walks you through any permission it needs, such as Screen Recording and Accessibility on a Mac. On a server with no desktop, it works without a screen and asks you before it sets one up. Tell it which chat apps to join. It sets them up itself on its computer and asks you only for what it cannot do, like signing in to Slack or approving the app. Leave with Ctrl+C; come back with pots chat.

It joins only the places it is invited to, like a new hire who is added to the right channels.

To upgrade, run npm install -g pi-durable-bot@latest, then pots service restart. To remove it, run pots service uninstall, then npm uninstall -g pi-durable-bot. The bots stay in ~/.pots/ until you delete that folder.

Choose the models

pots init sets up the model. Each bot's bot.json names two models, and you can change them at any time; edits apply within seconds. Logins, API keys and local endpoints are stored in pi's files in ~/.pi/agent/, so the pi command line, if you use it, shares them.

A fast classifier is cheaper and quicker than the main model: Jev answers in about 0.3 seconds. With main, each group of messages costs one short request to the main model.

OpenAI-compatible and local endpoints (Ollama, LM Studio, vLLM, a proxy): pots init adds them for you. By hand, they go in pi's ~/.pi/agent/models.json (fields):

{
  "providers": {
    "ollama": {
      "baseUrl": "http://localhost:11434/v1",
      "api": "openai-completions",
      "apiKey": "ollama",
      "compat": { "supportsDeveloperRole": false, "supportsReasoningEffort": false },
      "models": [{ "id": "qwen3:8b", "contextWindow": 32768 }]
    }
  }
}

Then set "model": "ollama/qwen3:8b". The agent needs a model that calls tools well and a context window of 32K tokens or more. In our tests a 4B model judged well but was too small to do the work alone; use the largest model your machine runs well.

llama.cpp can be both the agent and the judge. Start llama-server in router mode, then log in once with the pi command line: run pi, then /login llama.cpp (guide). Its chat models appear as llama.cpp/<model>. For the judge, use a decision model such as Kev-4B (3 GB), which answers through llama.cpp's /v1/systemone; any chat model also works as a judge.

{ "model": "llama.cpp/<your chat model>", "judge": "llama.cpp/Kev-4B-Q4_K_M" }

How it decides to act

flowchart LR
  E[New event] --> L[(Message log)]
  E --> M{Mention or DM?}
  M -- yes --> W[Wake the agent]
  M -- no --> J{Judge: about me?<br/>need to respond?}
  J -- yes --> W
  J -- no --> Q[Stay quiet, remember it]
  T[Its own timers] --> W
  W --> A{Agent reads the log<br/>and decides}
  A --> S[Speak, react or act]
  A --> N[Do nothing]

• Messages that arrive close together are grouped: it waits 3 seconds after the last one (20 seconds at most) before it judges.
• If it is already working in a place, new messages there are handed to it as it works, so it can change course.
• The wake message says only where, who, why and when. The agent reads the content itself.

How it works

flowchart LR
  subgraph Adapters[Channel adapters]
    S[Slack]
    T[Terminal]
    D[Discord, Teams, ...]
  end
  subgraph Gateway[Gateway core, one per bot]
    I[Inbox] --> G[(Message log)]
    G --> K[Waker]
    O[Outbox]
  end
  subgraph Bot[Bot]
    P[Persona, responsibilities, notes, timers]
    A[pi-durable agent<br/>read write edit bash<br/>send react call]
  end
  S --> I
  T --> I
  D --> I
  K --> A
  A --> O
  O --> S
  O --> T
  O --> D

One gateway process runs every bot on the machine. Everything lives in ~/.pots/ (or $POTS_HOME): one folder per bot in bots/, channel tokens in secrets/, the gateway's output in logs/ on macOS and Windows (on Linux, pots service logs reads the journal). Each bot folder holds:

The same pots command gives the bot (and its scripts and cron jobs) its actions from a shell: pots send, pots react, pots call, pots wake, pots context, pots turn-page. Tokens stay inside the running gateway; the agent never sees them.

Status

pi-durable-bot runs every day as a teammate in a real workspace. What works today and what is next:

• Slack adapter (socket mode), with backfill after downtime
• Mention, DM, judge and timer wakes, grouping, and steering
• Code mode on its own machine, pots command line
• Turning the page with notes, compaction as a fallback
• Crash-safe inbox and outbox, tested with a forced crash mid-send
• Several bots per machine
• pots init: name, AI and one sentence, then the bot sets up its own chat apps from the terminal
• macOS, Linux and Windows, as a background service of the user
• The screen, mouse and keyboard of its computer, used like a person (computer use), or no screen on a server
• Any model pi can use: subscription logins, API keys, OpenAI-compatible endpoints, local models
• A judge you choose: the bot's own model, Jev or another classifier, a local llama.cpp model, or none
• AGENTS.md, Agent Skills and images as in a pi session
• MCP servers
• More adapters: Discord, Teams, Telegram, email
• pots init in a web page, for people who do not use a terminal

Develop

git clone https://github.com/Crokily/pi-durable-bot && cd pi-durable-bot
npm install
npm run pots -- status    # the pots command, straight from src/ (Node 24 runs TypeScript)
npm run check             # type check
npm test                  # tests, including a real gateway with a fake model
npm run tla               # the TLA+ models of the inbox, outbox and waker (needs Java and tla2tools.jar)

npm run build writes the JavaScript that the npm package ships to dist/. Set POTS_HOME to try things without touching ~/.pots/. With OTEL_EXPORTER_OTLP_ENDPOINT set, the gateway also sends its traces to any OpenTelemetry tool (Jaeger, Grafana Tempo, Honeycomb). Tests, the TLA+ models and traces in detail: docs/development.md. Coding agents: read AGENTS.md. Agents that set Pots up for someone: read docs/for-agents.md.

Built on

• pi-durable for the durable agent runtime
• Chat SDK for channel adapters
• pi's model layer for logins, providers and local models
• Effect for the gateway core and the pots command line
• TypeSafe AI's Jev, one of the judges you can choose

License

MIT. The demo video, music, sky images and logo in docs/media were made for this project and use the same license.