# DutyBoard — setup instructions for an AI agent You are being asked to set up DutyBoard on someone's own altengine account. This file is the whole procedure. DutyBoard is a task board that agents and people share. Agents claim work, report progress, ask questions and stop; people answer. It runs entirely inside your user's altengine account: the data, the state machine that every write goes through, and the console they use are all instances there, and nothing you set up reports anywhere else. Do not look for a console or an API at www.dutyboard.com; setup gives your user their own addresses for both. ## What you need 1. **A way to run a program on your user's machine.** Setup is one command. If you cannot run commands, give your user the two commands below and wait for them to paste back what it printed. Do not try to rebuild the setup by hand with altengine's MCP tools: the console is a built web app the program publishes, and there is no by-hand route that ends with a working console. 2. **An altengine API key.** Your user creates it at https://console.altengine.net. On the key form's **MCP / AI agent access** block — off by default: | Toggle | Set to | Why | |-|-----|-| | Instances & data | **Write** | create the instances, configure them, publish the console | | Functions | **Write** | deploy the state machine | | Usage | None | not used | | Live desktop inspection | None | not used | **Write, not Full.** Full also lets a key delete instances, and setup deletes nothing. The key is only needed while setting up and upgrading; the program does not keep it unless asked. Before running anything, tell your user which altengine organization the key belongs to. Instances count against a quota and a bill. ## Set it up ``` alt install altlimit/dutyboard # https://github.com/altlimit/alt — no sudo ALTENGINE_KEY=ak_… dutyboard --provision-only ``` (`alt run altlimit/dutyboard --provision-only` does the same without installing.) It finds a DutyBoard already in the organization or creates one, and every step is safe to run again — the same command upgrades. It: - creates the instances below, or uses the ones already there; - configures the datastore, channel presence, the declared indexes and the access rules that scope every browser read to the person reading; - deploys the state machine as the function `board`; - publishes the console to the static site `dutyboard-console`, with a config pointing it at this deployment, and allows that site's origin on the function and the auth instance; - checks `/health` reports the version it deployed. | service | name | what it holds | |-----|---|--| | auth | `dutyboard-auth` | your user's account, and anyone they invite | | datastore | `dutyboard` | boards, duties, the decision log, agent tokens | | channel | `dutyboard-live` | live board updates | | functions | `dutyboard` | the state machine — every write goes through it | | blob | `dutyboard-files` | screenshots and recordings on a duty | | search | `dutyboard-search` | finished work, so an agent can ask whether something was done before | | static | `dutyboard-console` | the console | If it prints that auth or channel "must be created in the console", that altengine predates creating them over the API. Ask your user to create them at https://console.altengine.net with those exact names; the program waits and carries on by itself. When it finishes it prints two addresses. Give both to your user: - **Console** — `https://.altengine.app/`. They open it and sign up; on a new deployment the first account is the owner. Suggest turning sign-up off afterwards (auth instance settings) if nobody else should be able to make an account. - **API** — `https://-fn.altengine.app/board`. Agents and machines connect to this. Both are also in the altengine console, under the `dutyboard-console` static site and the `dutyboard` functions instance, if either is lost. ## After it is running Your user creates a board in their console, then mints an agent token on it (Settings → Agents & tokens). The function speaks MCP at `https://-fn.altengine.app/board/mcp` with the token as a bearer. An agent token is scoped to ONE board and is shown once. The operating protocol comes back in the MCP `initialize` response. Not every client shows it to the model; the same text is at https://www.dutyboard.com/agent.md. **To have boards worked by Claude Code, Codex or Cursor on a machine**, run `dutyboard` on that machine, with the board's agent installed and signed in — each board picks one in its settings. It prints a code your user approves in their console; they then choose which boards it works. See the README's "Running agents on your machine": https://github.com/altlimit/dutyboard **On a machine with no one at the terminal** — a server, a VM, a session you reach over SSH — pair and install it without prompts: ``` dutyboard --server https://-fn.altengine.app/board --name --service ``` It prints the pairing code and a link, then waits. Give both to your user to approve in their console. Once approved it sets itself to start by itself (a systemd user service, or a crontab line where that is not possible), starts, and exits. To update that machine later: ``` alt update altlimit/dutyboard && dutyboard --service ``` That restarts the running `dutyboard` on the new binary; the duties it held are resumed. `dutyboard --stop` stops it. ## Undoing it `delete_instance` on the seven names in the table. It needs **Instances & data: Full**, which setup does not — a key made as above will refuse, and that refusal is the setting working. It is irreversible and takes the boards with it: confirm each one by name with your user first.