The manual.

The terminal runtime that keeps programs and agents running.

1. Install and buildBuild from source with Rust, Zig and just, install lbc, and swap a running Core to a new build.
2. CommandsEvery lbc command and flag, generated from the binary’s own help.
3. MachinesAdding machines over SSH or a custom connection, remote files, and what to check when a connection fails.
4. Agent templatesThe template file format, readiness, and how the first message is sent.
5. Security and trustWho can connect, what sessions do and do not separate, where state lives, and how updates work.
6. APIThe OpenRPC document, plain and framed connections, the attach stream and event notifications.
7. Agent skillThe guide lbc --skill prints: how an agent delegates, waits, reports back and cleans up.

Guide: Core→About Core→Request access→

Desktop app for terminals and coding agents on all your machines.

1. Install and buildBuild from source with Rust and Zig, then run the Linux or macOS install script.
2. Spaces, tabs and agentsHow work is arranged, what each agent status means, and peeking at a worker.
3. MachinesAdding an SSH machine and what runs where.
4. CommandsEvery window action and its arguments, generated from the App.
5. Layouts and modsThe guide to layouts, settings, overlays, mod code and the App API.
6. KeysThe keys.json format and how to rebind any command.
7. Shared state in labelsThe seen and pinned labels that every Lumbridge client reads and writes.
8. Security and privacyWhat a mod can do, what stays on disk, and the local control socket.

Guide: The workspace→About App→Request access→

Terminal workspace manager for coding agents, local or over SSH.

1. InstallBuild from source with Rust and Zig, or with the Nix flake, then verify and update.
2. Quick start and conceptsWorkspaces, tabs, panes, agents, sessions, and the client and server split.
3. Agents and integrationsWhich agents are recognized, how state is detected, and what each integration installs.
4. Keyboard and configurationPrefix keys, copy mode, themes, notifications and the full config reference.
5. Connecting machinesSaved SSH machines, remote attach, reconnects and authentication recovery.
6. Session state and restoreWhat survives a detach, a server restart and a host shutdown, and how to recover a layout.
7. CLI reference and socket APIEvery command, the raw socket methods, event subscriptions and the JSON schema.
8. PluginsThe manifest, commands, event hooks, panes, link handlers and how to share a plugin.

Guide: The workspace→About TUI→Request access→

Lumbridge on Android, iOS and the web, with its gateway server.

1. ArchitectureThe rules that do not bend, the three admission checks, and why the gateway never starts a core.
2. A new phoneStep by step: admit the node, build and install on Android, pair, the iPhone Home Screen app, taking a phone off.
3. Approvals and questionsHow drafts and questions from agents reach the phone, the two-tap rule, and which devices may not approve.
4. Agent devices and MCPThe agent role, the short list of routes it may call, and the four notes tools served at /mcp.
5. DataNotes, tasks, thoughts and files: the tables, the migrations, the HTTP API and how conflicts are answered.
6. Android and iOS buildsThe Tauri shell, the app id, the build scripts, and what is still open on iOS.
7. Running and testingThe scratch instance, the throwaway database, the end-to-end suites and running two test runs side by side.

Guide: More machines→About Mobile→Request access→

Mods, layouts and keys that fit the App to how your team works.

1. InstallCheck, install and switch to the layout, and how to undo it.
2. Rules for mod authorsNaming, one owner per folder, copies not symlinks, read-only by default, gentle polling, no secrets.
3. Work loop for agentsThe skill an agent follows: orient, scaffold, build against the spec, check, look at it live.
4. SpecsOne spec per mod with its status, data sources, interface and done-when.
5. Building in parallelHow a wave runs: one spec per builder, one worktree each, one integrator who merges.
6. TrapsA numbered list of things that went wrong while building mods, with the fix for each.
7. Checks and CIWhat check.sh and ci.sh verify, and the logic tests that run without a window.

Guide: The workspace→About Mods→Request access→

A mail client where agents read and draft, and only a person sends.

1. Install and runBuild the three binaries, install them on a Linux desktop without sudo or as a macOS app, and keep the daemon running as a user service.
2. ArchitectureThe daemon, the store, the providers and the AI layer, and the decisions behind them.
3. Safety rulesThe seven rules every change must keep: hostile input, person-only send, sensitive mail, the anon wall, HTML, secrets and test data.
4. ProtocolThe JSON-RPC methods, events, error kinds and the person token, for anyone writing a client or an agent tool.
5. ConfigurationEvery key in config.toml: daemon timings, the AI endpoint and its place, accounts, personas, AI policy and read-only mode.
6. lbmail referenceEach command, its flags and exit codes, and how it decides whether it acts for a person or an agent.
7. ProvidersHow the Gmail bridge and the IMAP and SMTP provider map mailboxes, ids, drafts and sync cursors.
8. The desktop appPanes, keys, the composer, the AI panel, first run, notifications and read-only accounts.

Guide: Work apps→About Mail→Request access→

A terminal Markdown editor with live preview, over plain files.

1. Build and runBuild from source with cargo, the command line, and the notebook folder it opens by default.
2. KeysEvery shortcut: save, picker, search, find, source mode, tasks, the AI menu, templates, read aloud and dictation.
3. Note formatMarkdown with optional TOML front matter, slug file names, and the golden suite that pins the format.
4. ConfigurationThe [ai], [speech] and [dictation] sections of config.toml, the environment variables and the color settings.
5. Templates and promptsWhere they live in the notebook, their front matter, the placeholders, and the prompt actions replace, insert, append and answer.

Guide: Work apps→About Notes→Request access→

Private docs and a code warehouse, served to people and agents.

1. SetupThe database script, the config file, the token files and the systemd unit for lumbridge-libraryd.
2. ConfigurationListen address, library root, embedding and rerank endpoints, the vault remote, job timers and the librarian.
3. Docs shelfVault layers, search and ask, reading pages, clippings, wiki writes, facts and the lint report.
4. WarehouseMirrors and own repos, sync, repo cards, semantic search, grep, symbols and reading code at a commit.
5. Components and designsOrigins, license rules, the approval step, usage records, and adding a design from a capture.
6. MCP toolsConnecting an agent to /mcp, the resolve-then-query pattern, and what agents may and may not write.
7. Ledger, evals and exportsAnswer ids and verdicts, retrieval eval sets, and reproducible dataset exports.
8. Rules for contributorsGit as source of truth, append-only migrations, vector model ids and license handling.

Guide: Work apps→About Library→Request access→

Speech to text on your own GPU box: dictation and transcription.

1. HTTP APIEvery route of the front, its fields, responses and errors, with real answers from a running service.
2. Streaming protocolThe WebSocket at /v1/stream: options, the messages in each direction, endpointing and word boosting.
3. The Mac appKeys, the pill, the settings file, building and installing, and the three background agents it runs.
4. SettingsThe front’s TOML file and environment variables: listen address, adapter, upload limit, model address.
5. Verbatim and clean wordingWhy verbatim is the default instruction, with the measurements on repeated digits that decided it.
6. The Rust frontThe adapter trait, the mock model, and the listed places where it answers differently from the Python front.
7. EvaluationThe openly licensed test corpus, how to rebuild it, and the scripts that measure word errors after a change.

Guide: Voice→About Voice→Request access→

Text to speech with a Rust front and a speak command.

1. The speak commandEvery subcommand and option: say, voices, demo, check, text, stop, and speaking on another machine.
2. HTTP APIRoutes, request fields, audio formats, error messages and status codes, with real answers from a running front.
3. Numbers as wordsWhich written forms are rewritten, how phone numbers and versions are said, and how to turn it off.
4. SettingsThe TOML file line by line: listen address, adapter, default voice, level, the [say] table, drop patterns, targets.
5. Install on a MacWhat the installer writes, the background service it starts, where the log is, and how to remove it.
6. Adding a modelThe Synth trait, the mock adapter, and what a new adapter has to return.

Guide: Voice→About Speak→Request access→

Coding agents build from issues; CI and review gate every change.

1. DesignThe domain model, a ticket’s life from accept to merge, the three gates, capacity, reliability and the security rules.
2. agentdIts config file, how a turn stops, the tool hook, and a plain list of what the hook cannot stop.
3. factoryd and agentd protocolThe socket, every operation, turn idempotency, session ids and the eight turn outcomes.
4. Policy and configurationThe factoryd.json and agentd.json keys, with two complete instance examples in instances/.
5. Installing an instanceStep-by-step install logs with an undo beside every step: users, egress, bots, branch rules, CI runner and units.
6. Verifying the boundaryScripts that prove what each user can reach and that the bot cannot push or merge main.

Guide: Factory and models→About Factory→Request access→

One Rust binary that serves and switches open models on your GPU box.

1. Scenes and the registryThe manifest format: Scene fields, registry fields, model inheritance, and why a Scene never holds a command.
2. GatewayRouting rules, how the model name is found, streaming behavior, error codes and the flags that tune it.
3. OperationsScene state on disk, adopting running models, transactional switching, recovery and the supervision rules.
4. MemoryPer-model scopes and limits, measured footprints, admission on measured sizes, and the order the watchdog sheds models in.
5. Sleep and on-demandModel states, Scene modes, the registry’s sleep block, wake deadlines and the loopback-only rule for a sleepable engine.
6. The box fileThe lumbridge-computer.toml reference, every doctor check, and what apply --dry-run reports.
7. Usage telemetryWhich engines are understood, which numbers are stored, and the label contract for per-agent usage.
8. EvaluationsSuites in evals/, eval run against any OpenAI-compatible endpoint, and the time-to-first-token and decode-speed metrics.

Guide: Factory and models→About Computer→Request access→