All Documentation
Start here
How the room works
Working in a discussion
- The sidebar, projects and folders
- Where new sessions land
- Organisations, projects and folders
- The project page: instructions, files and memory
- Side-by-side sessions
- Channels
- Where channels live, and their AIs
- Threads, build sessions and tickets
- The title bar and the workbench
- Reading a discussion
- When the answer asks you something
- The Summary card under each run
- How a finished turn reads: Focused and Classic
- Acting on a reply
- The composer
- Depth, permission and the seat dock
- Guests: ask any model once
- Slash commands and the command palette
- The Summary panel
- Pull requests and CI from the discussion
- Pull request switches
- Work through a list
- Browser, simulator and other apps
- Pictures of your desktop app
- Your other discussions, from the room
- Ticket numbers: ours or Jira
- Jira for an organisation
Settings: The room
- Who's In The Room: the seats
- Seats beside the message box, and seats per discussion
- How a seat runs: Our Keys and Free Key
- How a seat runs: your CLI, your key, your endpoint
- How a seat runs: agents and your cloud
- More settings: provider, models and effort
- The Configure panel: testing, credit and CLI accounts
- Discussion Behaviour
- Review Policy
- Context: compacting turns and tool results
- Context: citations, closing answers, side chats and web pages
- Model Prompt Editor: your house rules
- Memory: what the room learns about you
- Memory: project notes and imports
- Notes, follow-ups and chapters from the lead
- Schedule: discussions on a clock
- Schedule: server runs, triggers and budgets
- Schedule: a repository as the workspace
- Schedule: started by GitHub
- Schedule: how often
- Schedule: who leads, on what, in which mode
- Loops: a discussion that repeats a prompt
- Prompt Library
- Prompt Library: editing and new-discussion preferences
- Skills: yours and your team's
- Plugins: MCP servers on your Mac
- Plugins: addresses, pinning and team limits
Settings: This Mac
- General: workspace and tools
- General: while the room works
- When background work finishes
- Delegated tasks
- Launcher and iMessage
- Logs and diagnostics
- Workspace: where it works
- Workspace: checks and instruction files
- Outside this window
- The sandbox: what a seat can reach
- Sandbox settings, part by part
- The network record
- Permission modes and what Auto asks
- Approval cards
- The Guardrails list
- Guardrails that work on their own
- Keeping secrets from models
- Prompt injection, tokens and MCP servers
- The warden
- Exceptions you have granted
- Storage
- Appearance: theme, language, notifications and voice
- Appearance: display
- Appearance: display, continued
Settings: Account
- Account: profile, sign-in and sync
- Account: sessions, devices and credentials
- Account: what this Mac shares
- Account: your data, links and deleting the account
- Account: GitHub, API keys and other apps
- Activity
- Team: create, invite and join
- Team: members, roles and limits
- Team: access, keys, secrets and integrations
- Coaching, the protection trend, and what the team holds
- Team: usage, reports, audit and logs
- Governance: profiles and who sets the rules
- What Careful and Locked change
- Governance: ownership and access
- Company Pays: no personal keys or subscriptions
- Governance: projects and spending
- Governance: models and data
- Governance: run safeguards
- Governance: modes and permissions
- Governance: tools and connections
- Governance: sharing and retention
- Governance: review requirements
- Governance: production, shipping and prompt guardrails
- Governance: evidence and accountability
Settings: Billing
Building on your machine
Models and keys
Tickets, projects and teams
Everywhere else
- Audit events: runs
- Audit events: jobs
- Audit events: approvals and refusals
- Audit events: seats and the network
- Audit events: seats and work
- Audit events: the Mac's own actions
- Audit events: the Mac's work
- Audit events: channels and the warden
- Audit events: background work and watchers
- Audit events: the team
- Web and iPhone
- Run on my Mac, and watching it live
- The command line, editors and automation
- The web app at letthemchat.com
- Web Settings, and how they differ from the Mac
- The iPhone app: Settings
- The iPhone app: drawer, discussions and sharing
- Slack and Microsoft Teams
- Telegram, Discord and iMessage
- GitHub and GitLab for your runs
- Pull-request reviews inside GitHub
- Pull-request reviews on your Mac
- The command line and editor extensions
- The ltb command
- Run in the Cloud: an overview
- Cloud Runs: work that carries on while you are away
- Cloud runs: commands, network and toolchains
- Cloud runs with the whole room
- Cloud runs and git: Pull Back, Open PR, Move Back
- Your free trial cloud run
- iPhone apps in a cloud run
- Cloud runs: building the iPhone app on your Mac
- ltb: discussions, projects, the room and your account
- MCP, A2A and the API
- Artifacts, published pages and decks
- Comments, versions and a page's store
- Pictures: real images from any seat
- Reports and exports
- Notices, notifications and the Inbox
- Notifications on the iPhone
Getting more out of it
Documentation
What LetThemBuild is, the ideas it is built on, and how to do the work. 175 pages, in the order they are worth reading.
Search finds pages. Ask answers from them, and links each part of the answer to its page.
The help centre answers one question at a time. Building against the API? The developer reference has the routes.
Start here
What this is, how to get it, and how to run your first discussion.
- What LetThemBuild isOne question, several AIs, and a record of what was actually checked.
- Quick startSign in, ask one real question, and read the agreed answer. About five minutes.
- Quick start on the MacPoint the room at a repository, let it make one small change, and open a pull request.
- Install and sign inDownload the app, sign in once, and everything else follows the account.
- Your first discussionAsk something real, watch the room work, and read the receipt at the end.
- How it fits togetherThe devices, your account, the room, the models, and the path a change takes on your Mac.
How the room works
The ideas everything else is built on: seats, rounds, agreement and evidence.
- Seats, the lead and the reviewersWho speaks, in what order, and which one is allowed to change your files.
- Rounds, agreement and the final answerHow the room converges, what happens when it does not, and how to give it more room.
- Depth: how hard the room worksFour presets that set how many seats take part and for how long.
- Evidence: verdicts, receipts and findingsWhat makes a review here worth more than an opinion, and how to read it.
- Reading the SummaryThe block under every answer: how it ended, what was run, and what nobody verified.
Working in a discussion
The window outside Settings: the sidebar, the transcript, the composer, the Summary and pull requests.
- The sidebar, projects and foldersStarting discussions, finding old ones, and filing them into projects.
- Where new sessions landNew Session always lands in General, your built-in project, in every mode and on every app. How to move a session, the folder the Mac gives it, and the one setting that changes it.
- Organisations, projects and foldersHow a company folder holds one project per product, what each project takes from it, and how the move to this layout renumbered tickets.
- The project page: instructions, files and memoryA project's home: what it is, a composer filed into it, and the three things every discussion there reads.
- Side-by-side sessionsEvery seat answers the same question on its own, in columns, to compare them.
- ChannelsA team feed of posts, each with its own thread, where one AI replies when it is wanted.
- Where channels live, and their AIsThe organization's channels and each project's in the sidebar, where a new channel lands, and the AIs beside a channel's box.
- Threads, build sessions and ticketsReplying in a thread, pulling in another AI, and turning a thread into tracked work.
- The title bar and the workbenchThe buttons along the top of the Mac window, and the tool panels they open.
- Reading a discussionWhat the labels on each turn mean, and why most of the transcript is folded.
- When the answer asks you somethingFull answers to general questions, and the short question an answer may end on.
- The Summary card under each runOutcome, checks, timing and cost for one run, and how to ask later whether it still holds.
- How a finished turn reads: Focused and ClassicThe answer first, then one Run Summary card that opens its details in Inspect.
- Acting on a replyCopy, read aloud, ask about a passage, rewind, find, share, and steer a run that is still going.
- The composerThe message box, what you can attach, and the chips that say where the work happens.
- Depth, permission and the seat dockThe chips that decide how hard the room works and what it may do, and who is in the room.
- Guests: ask any model onceInvite a model outside the room for one answer, in your own discussions and your team's, on every app.
- Slash commands and the command paletteEvery / command in the order the menu shows it, and the palette that finds everything.
- The Summary panelEverything about one discussion in a side panel: outcome, ticket fields, project notes and next steps.
- Pull requests and CI from the discussionThe git bar, the pull request rows, and having the room fix checks or merge when ready.
- Pull request switchesFix checks, merge when ready and archive on their own, switched from the Mac, the web or the iPhone.
- Work through a listHand over a backlog and come back to one pull request, unattended.
- Browser, simulator and other appsLetting the room look at and use what it builds: the browser pane, simulators, other Mac apps, and your phone.
- Pictures of your desktop appHow a seat photographs the Electron app it is working on, before and after a change, without touching your installed apps or their data.
- Your other discussions, from the roomHow a seat searches and reads your past discussions, and sends a message to another one, with what it may reach and the limits on a chain of messages.
- Ticket numbers: ours or JiraChoosing, per project, between LetThemBuild's own ticket numbers and real Jira issue keys, kept in step both ways.
- Jira for an organisationOne Jira project per product: connecting an organisation's projects to Jira, creating Jira projects, and one company board over all of them.
Settings: The room
Who sits in the room and how each seat runs, then prompts, memory, schedules, the library, skills and plugins.
- Who's In The Room: the seatsThe four seats, which model each one holds, which ones take part, and which one leads.
- Seats beside the message box, and seats per discussionThe seat dock under the composer, each discussion's own room, the room under Run on my Mac, one room for a discussion shared with your team, and seats your team holds.
- How a seat runs: Our Keys and Free KeyThe eight ways a seat can run, what the plan allows, and the two that need no key of your own.
- How a seat runs: your CLI, your key, your endpointRunning a seat on a coding CLI you already pay for, on your own API key, or on any OpenAI-compatible endpoint.
- How a seat runs: agents and your cloudAn ACP agent, somebody else's agent over A2A, or your company's Bedrock or Vertex account in a seat. All three are Mac only.
- More settings: provider, models and effortEverything else about one seat, unfolding under its card: which maker it holds, how hard each job thinks, and how fast it answers.
- The Configure panel: testing, credit and CLI accountsThe buttons at the foot of a seat's panel, several sign-ins for one CLI, and the role a seat reviews as.
- Discussion BehaviourHow many rounds the room runs, whether the answer is tested, whether the models rank each other, whether reviewers answer together, and how the answer is written and shown.
- Review PolicyWhat happens after the reviewers have spoken, and what each one is asked to look for.
- Context: compacting turns and tool resultsHow much of a model's window a discussion may fill before the room folds earlier turns and earlier tool results, and when the lead keeps its own model.
- Context: citations, closing answers, side chats and web pagesThe rest of the Context card, and how long the room keeps a web page a seat has read.
- Model Prompt Editor: your house rulesSeven sets of standing instructions, one per role, that each seat reads after its built-in brief.
- Memory: what the room learns about youThe Learning switches and the About you list: short facts read into every discussion, on every device.
- Memory: project notes and importsMemory kept per repository on the Mac, the notes a run saves to it from the Summary, and importing what you told other assistants.
- Notes, follow-ups and chapters from the leadHow the lead keeps a note in memory while it works, leaves you a follow-up to start later, and marks the chapters of a long run.
- Schedule: discussions on a clockRecurring discussions your Mac starts at a set time, with its seats, its tools and your checkout.
- Schedule: server runs, triggers and budgetsSchedules made on the web or iPhone run on our servers with no device awake: budget lines, overnight pricing, chains and HTTP triggers.
- Schedule: a repository as the workspaceA server schedule can name a repository the GitHub App covers: the room reads it, and what it writes becomes a draft pull request. Nothing is run or tested.
- Schedule: started by GitHubA server schedule starts when something happens on a repository the GitHub App covers: an issue opened, a push, a check or workflow that failed, a release, a pull request.
- Schedule: how oftenAt a time of day, every so many minutes or hours, or a five-field cron line, on the Mac and on our servers.
- Schedule: who leads, on what, in which modeA schedule can name the chair that leads its runs, the model it leads on, and (on the Mac) the permission mode, for that schedule only.
- Loops: a discussion that repeats a prompt/loop repeats a prompt inside the discussion it was typed in, on a fixed pace or at the lead's own, until there is nothing left to check.
- Prompt LibraryReady-made prompts, starting points, your own prompts and your team's shelf, to use now or schedule.
- Prompt Library: editing and new-discussion preferencesThe prompt editor, your own categories, comparing a copy with its original, and where Use now puts a prompt.
- Skills: yours and your team'sReusable instructions you call with /name: your own, the built-in ones, your team's, and a registry your team serves.
- Plugins: MCP servers on your MacGive the lead your issue tracker, database or browser through MCP servers this Mac runs or connects to.
- Plugins: addresses, pinning and team limitsHow a plugin by address is checked, why a server's tools are pinned at approval, and what a team can restrict.
Settings: This Mac
General, Workspace with its sandbox and guardrails, Storage and Appearance, in the order the Mac lists them.
- General: workspace and toolsWhere new work starts on this Mac, and whether the machine has what the room needs.
- General: while the room worksStaying awake during a run, and how background tasks report back.
- When background work finishesHow a discussion is picked up when a helper, a command or a watcher finishes after the lead's turn, and the limits that keep it from waking itself for ever.
- Delegated tasksHow the lead hands part of the job to a discussion of its own: read-only explore tasks and general ones.
- Launcher and iMessageAsking the room from any app on a shortcut, and from your phone by iMessage.
- Logs and diagnosticsLetting the seats read a running app's logs, finding the app's own errors, and naming the exact build.
- Workspace: where it worksThe folder the room works in, whether it gets its own checkout, and what follows a merge.
- Workspace: checks and instruction filesWhat the room must have reviewed before a commit, and which project files it trusts.
- Outside this windowThe room from a terminal and from your editor, with the seats and keys set up in the app.
- The sandbox: what a seat can reachHow the Mac holds every command and command-line seat to the project, and what stays out of reach.
- Sandbox settings, part by partEvery switch on the Sandbox card, the network list, the Swift and Xcode exception, and what a team can lock.
- The network recordWhat a Mac run's record of its connections holds: every host the sandbox saw, what each connection carried, and what is never written down.
- Permission modes and what Auto asksThe six modes on the composer's Permission chip, what Auto still stops for, and how Smart's judge decides.
- Approval cardsWhat a card offers, the order the checks run in, how long a card waits, and answering from your phone or the web.
- The Guardrails listEvery guardrail the Mac can keep for you, what each one does, and how a switch becomes a rule.
- Guardrails that work on their ownSession policies, protected instruction files, reviewed-only commits, file backups, folder warnings, and the brakes beyond them.
- Keeping secrets from modelsWhich credentials a seat can never read, what is masked before text leaves the Mac, and where that coverage stops.
- Prompt injection, tokens and MCP serversHow text from outside is kept from steering the room, and how short-lived GitHub tokens and pinned MCP tools limit the damage if it does.
- The wardenAn optional cheap seat that checks each action a run is about to take against what you asked, and can only stop the run.
- Exceptions you have grantedWhere every Always you answered is listed, how to take one back, and the rules you brought from other tools.
- StorageThe files this app wrote, the ones it only reads, and what worktrees take on disk.
- Appearance: theme, language, notifications and voiceHow the app looks on this Mac, the language it speaks, when it tells you a run is done, and the voice it reads in.
- Appearance: displayHow large the app is drawn, how much it moves, and what shows around an answer.
- Appearance: display, continuedHow a new discussion is named, what a message sent mid-run does, being told about a similar recent discussion, and when a ticket's due date changes colour.
Settings: Account
Your account, sign-in and data, then the team and its governance rules.
- Account: profile, sign-in and syncYour name on every app, how this Mac signs in and syncs, and the ways in to an account.
- Account: sessions, devices and credentialsEvery place signed in as you, the computers your phone can hand work to, every token the account holds, and how to end them.
- Account: what this Mac sharesWhether your phone and the web may run work here, how private new discussions are, GitHub for seats, phone pairing and previews, and resetting the app.
- Account: your data, links and deleting the accountExport everything the server holds, see every public link, set the analytics choice, and delete the account.
- Account: GitHub, API keys and other appsConnect GitHub for runs and pull-request reviews, mint API keys for your own code, and link Telegram or Discord.
- ActivityWhat this Mac has done: tokens, streaks, what the room shipped, and which seats did the work.
- Team: create, invite and joinStart a team, invite people, answer an invitation, and what the Team plan shares.
- Team: members, roles and limitsThe four roles and what each sees, per-member budgets, member places, leaving, and tickets-only mode.
- Team: access, keys, secrets and integrationsVerified domain, company sign-in, directory provisioning, project access, shared provider keys, run secrets, Slack and Microsoft Teams.
- Coaching, the protection trend, and what the team holdsA note in the team's words on every refusal, a twelve-week view of what the protections stopped, and a scan of what sits in the team's own discussions.
- Team: usage, reports, audit and logsBudget requests, inventory and results, where audit events go, the auditor pack and export, and pausing or deleting the team.
- Governance: profiles and who sets the rulesWhat a team's Governance page is, who may change it, the Open, Careful and Locked profiles, and the policy members acknowledge.
- What Careful and Locked changeLine by line, what each Governance profile sets, and how to hold one project or every automation to a stricter profile.
- Governance: ownership and accessEvery line in the Ownership & access card: the accountable owner, violations as tickets, fresh sign-ins, acknowledgement, domains, accounts, IP ranges, auditors and tokens.
- Company Pays: no personal keys or subscriptionsIn the team's discussions and projects, every turn runs on the team's keys or the team's credit, never on a member's own key, endpoint or subscription.
- Governance: projects and spendingEvery line in the Projects & spending card: team projects, who sees them, the team's ceiling, rate limits, the spend export, alerts, What's metered and overnight pricing.
- Governance: models and dataEvery line in the Models & data card: which providers and models may run, zero data retention, training, privacy level, EU-only calls, masking and analytics.
- Governance: run safeguardsEvery line in the Run safeguards card: what must be true before a run starts, and what stops one.
- Governance: modes and permissionsEvery line in the Modes & permissions card: what members start with, the loosest mode they may run in, and the rules that answer approvals.
- Governance: tools and connectionsEvery line in the Tools & connections card: MCP servers, private hosts, registries, hooks, tool families, apps, origins and environment variables.
- Governance: sharing and retentionEvery line in the Sharing & retention card: public links, one room per shared discussion, shared prompts, link expiry, the monthly export, scanning before a share, retention and memory review.
- Governance: review requirementsEvery line in the Review requirements card: reviewer independence, the depth floor, light paths, list-run checkpoints, the device roster, the baseline and objectives.
- Governance: production, shipping and prompt guardrailsEvery line in the Production & shipping and Prompt guardrails cards: what counts as production, what a push must pass, and rules on what people ask.
- Governance: evidence and accountabilityWhat the team can show: What's metered, audit deliveries, the auditor pack and compliance API, the inventory, Results, the device roster and the behaviour baseline.
Settings: Billing
Spending limits, what you have spent, your plan, and how the AIs are doing over time.
- Spending brakesThe ceilings on what one discussion or one turn may cost, the costs-more-than-usual question, Keep going, and the other brakes on the Spending page.
- What you have spentThe usage dashboard on the Spending page: ranges, Mine and Team, the breakdowns, At this pace, savings and waste, where calls went and how they were paid.
- Budgets, alerts and the spend exportMonthly budgets per provider, spike alerts, the CSV spend export, overnight pricing for schedules, and checking estimates against your provider's own bill.
- Plan and billingYour plan, your credit, top-ups, auto-reload, yearly Pro and changing or cancelling a plan.
- InsightsHow your AIs are doing over a period: spend, runs, agreement, time and errors, by model, with the change since the period before.
Building on your machine
The desktop app: workspaces, what the room is allowed to touch, and git.
- Workspaces and projectsWhere a discussion works, and how to keep several pieces of work apart.
- What the room is allowed to doSix modes, from read-only to unattended, and the approvals in between.
- Git: branches, commits and pull requestsThe repository strip, and the next real step rather than the last one.
- Watching and checking the workThe workbench, the terminal, and how to satisfy yourself it is right.
Models and keys
Who sits in the seats, whose account pays for them, and how to change either.
Tickets, projects and teams
Every discussion is a piece of work you can track, assign and share.
Everywhere else
The web app, the iPhone app, and driving your Mac from either.
- Audit events: runsThe contract behind the audit webhook, the auditor pack and the OpenTelemetry export, generated from the code.
- Audit events: jobsThe audit catalogue's job events: planning, tasks started, pull requests opened, re-plans, pauses and stops from any device, and runs resumed after a restart.
- Audit events: approvals and refusalsThe second page of the audit catalogue: questions asked before acting, refusals, and outside material treated as data.
- Audit events: seats and the networkThe third page of the audit catalogue: the seats, the servers they reach for, and the hosts a run touched.
- Audit events: seats and workThe third page of the audit catalogue: seats and the record of the work.
- Audit events: the Mac's own actionsThe fifth page of the audit catalogue: imports, folders, previews, phones, file editors and the reset.
- Audit events: the Mac's workThe sixth page of the audit catalogue: commits, what the room wrote, code health, classified data, hand-overs, CLI sign-ins, tickets and alerts.
- Audit events: channels and the wardenThe audit catalogue's channel events — a discussion becoming a channel, who answered a post, work started from a thread — and the warden's stops and Allow Once.
- Audit events: background work and watchersThe audit catalogue's events for background work that comes back after the turn: picked up, joined, held or dropped, and the watchers the lead set.
- Audit events: the teamThe fourth page of the audit catalogue: what changed on the team itself, the policy, the domain, budgets, tokens and the pause.
- Web and iPhoneThe same account and the same discussions, wherever you are.
- Run on my Mac, and watching it liveStart work from your phone, watch it happen, and answer its questions from there.
- The command line, editors and automationDriving the same engine from a terminal, an editor, a schedule or another program.
- The web app at letthemchat.comWhat is where in the browser: the sidebar, a discussion, the room panel, notices and the Inbox.
- Web Settings, and how they differ from the MacThe web's Settings in the order it shows them, and what is only on the web or only on the Mac.
- The iPhone app: SettingsWhere things are in the iPhone's Settings, including the App group that only the phone has.
- The iPhone app: drawer, discussions and sharingThe discussion list, a discussion on the phone, answering your Mac's approvals, and the share sheet.
- Slack and Microsoft TeamsAsking the room from a team's chat: what the chat apps share, and how Slack and Teams are connected.
- Telegram, Discord and iMessageYour own bot in Telegram or Discord, and iMessage answered by your Mac.
- GitHub and GitLab for your runsShort-lived GitHub tokens for runs on your Mac, and what a GitLab checkout gets.
- Pull-request reviews inside GitHubInstall the GitHub App on a repository or organisation, and the room reviews pull requests there.
- Pull-request reviews on your MacRun the GitHub App's reviews on the pull request author's own Mac, CLI subscriptions included, with the server as the fallback.
- The command line and editor extensionsltb in a terminal, remote control from your phone, the room inside an ACP editor, and the VS Code and Cursor extension.
- The ltb commandltb in a terminal: the commands that do work, their options, where a run works outside a project, approvals and exit codes.
- Run in the Cloud: an overviewHand a task to the cloud, close your laptop, and approve from any device. What it does, what each plan gets, and what it costs.
- Cloud Runs: work that carries on while you are awayHand a discussion's work to the cloud worker, then watch it, approve its commands and stop it from the web, the iPhone, the Mac or the terminal.
- Cloud runs: commands, network and toolchainsWhich commands a cloud run may run without asking, what it may reach on the network, and which language tools it gets.
- Cloud runs with the whole roomHow a cloud run takes the room with it: the lead works, the other seats review before it counts as done, the warden checks each action, and which seats sit it out.
- Cloud runs and git: Pull Back, Open PR, Move BackHow a cloud run handed over from a checkout comes back as a branch of its own, a pull request, or a discussion carrying on here.
- Your free trial cloud runThe free plan's one cloud run: a small machine, a capped spend and a short time limit, paid from your credit, once per account.
- iPhone apps in a cloud runWhy the start screen warns when the files hold an Xcode project, and what happens to the app's code in the cloud.
- Cloud runs: building the iPhone app on your MacAfter Pull Back or Move Back to This Mac, your Mac builds a cloud run's iPhone app for the iOS Simulator and runs its tests, and every device shows the result.
- ltb: discussions, projects, the room and your accountThe ltb commands that read and change what the app has: discussions, tickets, seats and models, channels, automation and your account.
- MCP, A2A and the APIThe room as a tool in another assistant, as an agent another agent calls, and through the HTTP API.
- Artifacts, published pages and decksEverything the room made for you in one place, pages you can open from a link, and slide decks.
- Comments, versions and a page's storeA published page stays alive: readers comment and the room hears it, every rewrite keeps the version before, and a page can keep a small store its viewers write to.
- Pictures: real images from any seatAsk for an image and get one: which model makes it, on whose key, what it costs, and who can switch it off.
- Reports and exportsHTML reports in answers, report pages with a done box on every row, and the formats an agreed answer saves to.
- Notices, notifications and the InboxHow the app tells you things on each platform, and the switches for each.
- Notifications on the iPhoneBanners from the server when a discussion finishes, your Mac needs an answer, or your inbox has something, even with the app closed.
Getting more out of it
The things that make a long week easier: memory, skills, attachments and what you can do with an answer.
Reference
Plans and money, the keys on your keyboard, privacy, and how to reach a person.
- GlossaryThe words the app uses, in one place, in alphabetical order.
- The brief's changelogWhat changed in the standing instructions every seat is sent, and when; each receipt names the version it ran under.
- The brief's changelog: before October 2026The changes to the standing instructions every seat is sent from the start of the changelog to the end of September 2026.
- Plans, credit and what a month costsWhat each plan gives you, and how the money actually works.
- Keyboard shortcutsThe ones worth learning, on the desktop app.
- Privacy and what leaves your machineWhere your code goes, where it does not, and what we keep.
- Getting help, and telling us when it is wrongThe help centre, support, and what the thumbs under an answer are for.
Start at the top
New here? The Quick Start gets you to a first agreed answer in about five minutes. If you would rather understand it first, read What LetThemBuild is and Evidence. The four Settings sections follow the apps' own Settings, card by card, so you can read along with the app open.