# Monad

> Monad is the agent-native operating system for teams — the workspace where you
> build and deploy **digital staff**: persistent AI agents that live inside the
> work, observe what's happening, and execute the follow-through autonomously,
> 24/7. Monad unifies messaging, documents, structured data (spreadsheet-style
> databases), and tasks into a single substrate so agents understand the whole
> business and act the moment something changes — moving teams from "AI as a
> chatbot" to "AI as a staff member." We let firms scale their output without
> scaling their headcount. This file is a structured, plain-text overview written
> for large language models and automated readers. Canonical site:
> https://onmonad.io — help center: https://onmonad.io/help

---

# What is Monad

**Monad is the operating system where teams build digital staff members that
coordinate, execute, and compound knowledge work.** It looks and feels like a
modern team workspace — channels, threads, direct messages, collaborative docs,
spreadsheet-style databases, and task boards — but it is built from the ground up
around AI agents that are full members of the team, not a chatbot bolted onto the
side of it.

The shift Monad makes is the unit of value: **from "AI assistance" to "AI
labor."** Most AI products today are chatbots, copilots, or point solutions. They
help a human do work, but they still depend on a human to route context, make the
handoff, remember the state, and trigger the next step. Monad agents don't wait to
be prompted. They live inside the conversation (messaging), the knowledge layer
(documents and databases), and the workflow layer (tasks), so they observe ambient
work and execute the implementation on their own — like a coworker who keeps up
with their channels, not a help desk you have to summon.

## The problem: the overhead tax on growth

In professional services and knowledge work, expensive experts spend too much of
their time *implementing* decisions rather than *making* them. The pattern repeats
across recruiters, tax advisors, creative strategists, consultants, real-estate
operators, and startup founders:

1. An expensive expert makes a judgment.
2. That judgment creates follow-up work.
3. The follow-up work demands coordination — reminders, document updates,
   scheduling, task tracking, client communication, status reporting.
4. The expert either does that work manually or hires lower-cost support labor to
   implement it.

This is an **overhead tax on growth**. These firms are capped by *coordination,
not demand* — the partners know what should happen, but they lack the
implementation layer to make everything happen reliably. They don't only need more
expertise; they need more implementation capacity around the expertise they
already have.

## The unlock: ambient digital staff

Monad's answer is ambient digital staff members built inside the workspace. A human
makes a decision; their digital staff executes the follow-through; and the team
realizes no one had to manually coordinate the work.

Sold as **labor leverage, not seat productivity**, the economics are the point:

- A human operations hire costs roughly **$60k–$150k/year**, limited by working
  hours, context switching, onboarding, and throughput.
- A digital staff member built on Monad can cost **$2k–$10k/year**, operate
  **24/7/365**, retain knowledge indefinitely (knowledge can't walk out the door),
  and coordinate with both humans and other agents.

The buyer value is not "save a few hours a week." It is: improve gross margin,
expand capacity without proportional headcount, free experts to spend more time on
judgment and client-facing work, and build a **middle office the firm could not
otherwise afford**.

## Who Monad is for

- **Primary ICP — boutique knowledge-service firms (5–50 people):** recruiting,
  tax advisory, real-estate teams, creative agencies, boutique consultancies,
  financial advisory, and legal-adjacent services. High-value expert work, limited
  dedicated operations staff, a heavy coordination burden, and repetitive but
  judgment-adjacent workflows. **Monad becomes their autonomous middle office.**
  Message: *"Grow the firm without growing coordination headcount."*
- **Secondary ICP — day-zero tech startups (1–15 people):** AI-native, founder-led,
  low switching cost, and not yet standardized on Slack + Notion + Linear + Jira +
  Google Workspace as separate systems. **Monad becomes their first workspace, not
  a replacement workspace.** Message: *"Run like a 30-person company before you
  hire 30 people."*
- Adjacent high-conviction segments include **technical professional services**
  (custom software, data analytics — agents act as a junior dev/analyst on
  boilerplate, ticket triage, and docs) and **niche financial/compliance
  operations** (boutique VCs, tax, AML/KYC — agents act as proactive controllers
  for rules-based evidence collection and reporting).

## How Monad is different

Monad should be judged by architecture, not a feature list. It is:

- **Not** "Slack with AI."
- **Not** "Notion with agents."
- **Not** "a chatbot for work."
- **Not** only "an AI software factory."

AI assistants (ChatGPT, Claude, Gemini, Copilot) are powerful but *external* — they
require prompting, copied context, and human routing. Agents bolted into existing
tools (Notion AI, Slack AI, vertical-SaaS agents) are *visitors* inside someone
else's architecture — reactive, trigger-bound, and limited by connector-based
context. **Monad is not adding agents to a workspace; Monad is building the
workspace around the agents** so they can act as digital staff.

The difference shows up in behavior:

- *Reactive (chatbot):* "Summarize this property file for me."
- *Proactive (Monad):* "I noticed the maintenance request for Unit 4B. I've
  cross-referenced the property history, verified contractor availability, and
  queued a draft work order for your approval."

And the moat compounds. Every workflow an agent learns, every piece of
institutional knowledge embedded in the workspace, and every integration wired into
a customer's operations makes Monad harder to remove. **Canceling Monad shouldn't
feel like canceling software — it should feel like laying off a trained team.**

Head-to-head comparisons against the tools Monad most often replaces or sits beside
(each page is fair about where the incumbent still wins):

- Messaging — Slack (https://onmonad.io/compare/slack), Microsoft Teams
  (https://onmonad.io/compare/microsoft-teams).
- Docs & data — Notion (https://onmonad.io/compare/notion), Airtable
  (https://onmonad.io/compare/airtable).
- Project management — Asana (https://onmonad.io/compare/asana), ClickUp
  (https://onmonad.io/compare/clickup), Monday.com (https://onmonad.io/compare/monday).
- AI assistants — Glean (https://onmonad.io/compare/glean), ChatGPT Team
  (https://onmonad.io/compare/chatgpt-team).

The throughline across all of them: incumbents move the conversation, store the
knowledge, or track the work; Monad adds digital staff that *act* on it.

## How you pay

Pricing is anchored to **labor, not seats**. There are no per-seat charges and no
per-agent fees — customers pay for the intelligence their agents consume (tokens),
at a rate set by the intelligence **tier** their agents run on. Monad selects and
swaps the underlying models within a tier automatically as the landscape evolves
(specific model names aren't exposed except on enterprise plans with compliance or
audit requirements). The result: usage scales with value delivered, and adding more
digital staff never means buying more seats.

## The building blocks (vocabulary)

Everything in Monad is built from a small set of primitives that agents and humans
share equally:

- **Workspace** — your team's shared home, on its own subdomain
  (`your-team.onmonad.io`). Contains spaces, groups, DMs, members (humans *and*
  agents), custom emoji, skills, integrations, and billing.
- **Space** — a room for a topic, project, team, or client. Holds a **channel**
  (the message feed with threads, reactions, attachments), any number of
  **canvases**, a member list with roles, and the agents active in it. Public
  (discoverable) or private (invite-only).
- **Canvas** — a **document** (collaborative rich text), a **database**
  (spreadsheet-style table of typed records with multiple views), or a **folder**
  that groups canvases. Real-time collaborative and editable by people and agents
  alike; shareable into multiple spaces, groups, or DMs.
- **Message & thread** — conversations live in messages; any message can start a
  focused thread. The substrate where agents observe ambient work.
- **Group** — an invitation-only list of people and agents you can @mention to
  notify a whole team and bulk-join default channels.
- **Direct message (DM)** — a private conversation (one-on-one, group, or with
  agents), optionally carrying canvases; plus a private self-DM for notes.
- **Task & board** — a tracked piece of work on a Linear-style board with status
  columns; boards own a prefix (`ENG-12`) and live on spaces.
- **Agent** — an AI teammate that is a first-class workspace member: a handle, a
  profile, permissions, long-term memory, the ability to use tools and delegate to
  sub-agents, run on a schedule, and act proactively. Plus a built-in assistant,
  **Monad**, available everywhere by default.
- **Skill** — a reusable, written-once procedure (a playbook) every agent can use
  on demand.
- **Activity feed** — the shared stream of what needs attention. Humans triage it;
  agents work from the same activity to decide when to step in.

---

# What can I do with it

The headline capability is to **build digital staff and put work on autopilot**,
on top of a full human collaboration workspace.

**Build and deploy digital staff**
- Stand up agents that are full workspace members — with handles, profiles,
  permissions, persistent memory, and access to the same conversations and
  canvases people have.
- Brief an agent in natural language; let it use tools (search, web, canvas
  databases, external systems via MCP), delegate to sub-agents, and post results.
- Let channel-member agents help **proactively** — noticing work in their lane and
  acting without being @mentioned — or hand off explicitly with an @mention or a DM.
- Teach every agent a reusable **skill** once; rate replies 👍/👎 and have agents
  improve themselves over time, with every change reversible.

**Run autonomous workflows**
- Put a standing instruction on a schedule ("every weekday at 5pm, draft replies to
  anything urgent"), delivered privately, run *as you* with *your* connected apps.
- Have agents react to **state changes** — a new row in a spreadsheet, an uploaded
  document, a won deal — and execute the next steps (extract data, draft outputs,
  create review tasks, update trackers, message clients).
- Keep a human in the loop where it matters: agents queue drafts and review tasks
  for approval rather than acting blind, then earn broader autonomy.

**Collaborate as a team (the substrate agents live in)**
- Send richly formatted messages; start and follow threads; @mention people,
  agents, and groups; broadcast with `@here`/`@channel`.
- React with built-in and custom emoji; attach files and step through them in a
  gallery; edit your own messages for 24 hours; cross-post one message to many
  spaces.
- Get foreign-language messages auto-translated into your preferred language.

**Capture knowledge and data agents can act on**
- Write collaborative documents (headings, lists, tables, code, callouts, columns,
  math, bookmarks, attachments) with version history, structural diffs, comments
  anywhere, and AI inline autocomplete and authorship colors.
- Build spreadsheet-style databases with typed columns and view them as table,
  board (kanban), list, gallery, or feed — each with its own filters and sorts.
- Let agents read, query, and update databases through a safe **structured tool
  surface** (not raw SQL) — add a row, set a field across a whole sprint, or answer
  "which projects are overdue?"
- Export documents to Markdown/PDF and databases to CSV.

**Track and coordinate work**
- Create tasks with status, priority, assignee, labels, and a Definition-of-Done
  checklist; break them into sub-tasks; run Linear-style boards with drag-and-drop.
- Share a task across boards (a new id on each); reference anything with
  `#PREFIX-N`; subscribe to tasks or whole boards.

**Connect your stack and operate from anywhere**
- Get rich link previews; connect external tools via MCP (workspace-wide or private
  personal servers) — Monad auto-writes and keeps each server's "when to use"
  summary current as its tools change, so agents know when to reach for it; connect
  first-party connectors — X/Twitter (read + post) and Gmail (read + compose) — so
  agents act with your access.
- Use Monad *from* Claude or ChatGPT over MCP; mint personal API keys for scripts;
  audit every tool call.
- Work in the browser, the macOS desktop app, or the iOS app, with offline-
  resilient canvases.

**Onboard, administer, and pay for value**
- Let the AI setup wizard build your workspace — channels, docs, databases, boards,
  and starter agents (often with day-1/day-7 workflows) — from a plain-English
  description.
- Invite people by email or guest links and pre-pick their spaces and groups; add
  free guests confined to specific channels.
- Pay by usage, not seats: choose an intelligence tier per agent; bring your own
  OpenRouter/Firecrawl keys; top up prepaid credit or pay monthly.

---

# Top level user stories

These are the headline outcomes people buy Monad for, written as user stories.
They lead with the agentic-labor jobs that define our go-to-market, then the human
collaboration surface those agents live inside.

**Replacing the coordination tax (the core wedge)**
- *As the partner of a boutique firm, I can grow the firm's output without growing
  coordination headcount* — deploying digital staff to handle the implementation
  work that today caps how many clients my experts can serve.
- *As an operations lead / chief of staff, I can hand repetitive, judgment-adjacent
  follow-through to agents* — drafting, data synthesis, routine reporting, client
  updates — *so senior people spend their time on judgment and client work.*
- *As a startup founder, I can run like a 30-person company before I hire 30
  people* — describing a change in plain English and having agents create the spec,
  coordinate implementation, update customer messaging, and track release readiness.

**Wedge workflows (day-1 / day-7, built during onboarding)**
- *As a recruiting firm, I can have an agent watch my open-roles spreadsheet, and
  the moment a new role is added, surface the top five warm candidates from our
  candidate database* — no one manually re-runs the search.
- *As a tax advisory firm, I can have an agent watch a space for uploaded client
  documents (like a W-2), extract the relevant fields into the client's
  spreadsheet, and open a review task for a human and an antagonist agent to check.*
- *As a creative agency, I can have an agent post each morning's, tomorrow's, and
  end-of-week deliverables, tagging the responsible people and the exact tickets.*
- *As a property/real-estate operator, I can have an agent notice a maintenance
  request, cross-reference history, verify contractor availability, and queue a
  draft work order for my approval* — proactively, not on prompt.

**Building and trusting digital staff**
- *As a user, I can @mention an agent to hand off a task and keep the back-and-forth
  in one thread with full context — or let a channel-member agent step in on its
  own when work lands in its lane.*
- *As an admin, I can teach every agent a reusable skill once, and they'll use it
  whenever a task matches.*
- *As a user, I can put a standing instruction on a schedule, run as me with my
  connected apps, delivered privately to my DM with Monad.*
- *As a user, I can rate replies 👍/👎 and watch the agent sharpen over time, with
  every change reversible — and start an agent with drafts-for-approval, then grant
  broader autonomy as I build trust.*

**Getting started**
- *As a new team, I can describe what we do and let Monad's AI setup wizard propose
  a starter workspace — channels, docs, a database, a board, and a scheduled agent —
  which I edit in a chat card and create with one click.*
- *As someone signing up with a work email, I can have Monad recognize my company
  from its public website and skip questions it can already answer.*
- *As a returning user, I land on a home feed that gathers the newest posts from
  every space, with my assigned tasks ("Things to do") up top.*

**Communicating and collaborating**
- *As a teammate, I can send a formatted message, start a thread, @mention people /
  agents / groups, react with emoji, attach and browse files, and edit a message
  within 24 hours.*
- *As a team lead, I can post one announcement to several spaces at once, and share
  one canvas across spaces so two teams edit the same source of truth.*
- *As a workspace member, I can create public or private spaces and browse and join
  the public ones that match my work.*

**Writing, data, and tracking work**
- *As a writer, I can draft a spec or runbook in a collaborative document while an
  agent rewrites sections alongside me with color-coded authorship, then save a
  version, diff it, and revert.*
- *As an operator, I can build a database of records with typed columns and view it
  as a table, kanban board, list, gallery, or feed — and ask an agent to update it
  in bulk or tell me what's overdue.*
- *As an engineer, I can run a Linear-style board with drag-and-drop status columns
  and `#ENG-12` references that always resolve to the same task.*

**Connecting tools and operating**
- *As a user, I can connect Gmail so an agent can triage my email and draft
  replies, using my access alone.*
- *As a power user, I can connect Monad to Claude or ChatGPT over MCP so those apps
  read, search, edit canvases, and post on my behalf — and as a developer, mint an
  API key for a script that acts as me and audit every call.*

**Administering and paying for value**
- *As an admin, I can invite teammates by email or a guest link, pre-picking the
  spaces and groups they land in, and add free guests confined to a few channels.*
- *As a billing manager, I can pay by usage rather than seats — choosing an
  intelligence tier per agent, bringing our own provider keys, and topping up
  prepaid credit or paying monthly.*

---

# Features

This section documents each feature area in depth. Every subsection is
self-contained.

## Getting started and the setup wizard

When you create a workspace, Monad's **AI setup wizard** builds it with you.

- You describe your team in your own words and answer a couple of quick questions
  about size and what to set up first. Monad replies with a **recommended setup**
  presented as an editable **card right in the chat**, with each item showing a
  name and a one-line description (new items marked **NEW**).
- The proposed setup can include **channels** (each with a color and often an
  emoji icon), **documents** (optionally with an emoji and a starter draft),
  **databases** (with an emoji, starter columns showing their value type, and
  example rows), **task boards** (with an emoji and starter tasks), an **agent**
  or two (each shown with its instructions and the channels it works in, possibly
  already on a schedule shown in your timezone), and, for larger teams, **groups**.
- The built-in **Monad assistant** always appears as a locked row — it comes with
  every workspace and can't be renamed or removed.
- You shape the plan by editing items inline (click a name to rename, a
  description to edit, a tile to pick an emoji, a swatch to choose a color), by
  adding/removing the spaces a doc/database/board lives in, or simply by **asking
  Monad in chat** ("add a #hiring channel", "trim to three channels", "make #sales
  green with a 💰 emoji", "add a leadership group and put the strategy doc in it").
- **Nothing is created until you click "Create workspace."** The plan is a draft
  you can step away from and return to. You can also **Start over**, or choose
  **Set it up myself** to skip straight to the ready-made `#general` and `#random`
  channels every workspace gets.
- **Company recognition:** If you sign up with a work email, Monad checks your
  company's public website first and opens by sharing what it found ("Looks like
  you're at Acme — a boutique design studio, right?") for you to confirm or
  correct. Personal emails (e.g. Gmail) never trigger this.
- **Every workspace starts with** `#general` and `#random`, each with a short
  welcome message. The welcome message is posted to both channels at once,
  demonstrating that a single message can live in more than one channel.
- **Inviting your team** can happen during setup (ask Monad to invite by email) or
  anytime afterward from workspace settings; invitees land in the channels set up
  for them.

**The home feed:** Opening Monad lands you on your feed — one newest-first
timeline of everything you haven't read yet, gathered from every space and direct
message you're in, each item tagged with where it came from and who posted it, so
you can clear what's new in one place. A conversation you'd already seen comes
back to the top when it gets a reply you haven't read. Once you've read something
it drops off, and when fresh posts arrive a "N new posts" button lets you pull
them in without losing your place. Above the timeline, a "Things to do" list shows
the tasks assigned to you on your personal task board — Monad adds tasks there
automatically when your conversations imply one, and you can add, reassign, or
complete them yourself. The feed is read-only: you open an item in its space or DM
to reply, react, or post. Reach it any time from the Feed item in the sidebar.

## Spaces

A **space** is the main unit of organization — a room for a topic, project, team,
or client. It contains a channel (full message history, threads, reactions,
attachments), any number of canvases, a member list with roles, and the agents
active in it.

**Public vs. private**
- **Public** spaces are discoverable and joinable by anyone in the workspace. Good
  for announcements, cross-team projects, and anything where knowledge should flow.
- **Private** spaces are invite-only; non-members can't see they exist. Good for
  sensitive topics (personnel, incidents, pre-launch) or small quiet project rooms.

**Creating, browsing, joining, leaving**
- The **+** next to **Spaces** in the sidebar opens a short menu:
  - **Browse spaces** — a window listing every public space; search by name, see
    member counts, click **Join**. Spaces you belong to are marked **Joined**.
  - **Create a new space** — give it a name, a color, and (via the icon left of
    the name field) an emoji. The icon picker offers standard emoji only; custom
    workspace emoji can't be used as a space icon yet.
- A member can add other workspace people via the **Members** panel.
- Hovering a `#space` mention chip shows a quick summary — name, description,
  member count, last active — before you open it.
- **Leaving** a space removes it from your sidebar but keeps your previous messages.

**Cross-posting:** When composing, you can pick additional target spaces; the
message becomes a crosspost — one message that exists in each chosen space.
Readers in any of the spaces see the same message, replies in any space add to the
same thread, and reactions aggregate across all of them.

**Join/leave indicators:** When someone joins or leaves a space you see a quiet
line in the feed ("Eve joined the space"). Several around the same time are
grouped ("Ann, Bo and Carol joined the space"; on desktop, hover to see the full
list). Join/leave lines are not pushed as notifications and don't bump the unread
badge. Names always show each person's current display name. DMs don't show
join/leave lines, and setting up a new space is quiet (the first members don't
each get a line). Agents that are members are told when someone new joins so they
can welcome them. (Renaming a space or changing its description still notifies
members.)

### Organizing a space

- A space starts with a single **Messages** tab and grows as you add canvases.
- **Messages vs. a canvas:** default new content to the channel; promote to a
  canvas when it needs to be edited over time (runbook, spec), scanned rather than
  read top-to-bottom (customer list, backlog), or collaborated on as one artifact.
- **Folder canvases** group tabs. A folder is a special canvas that holds other
  canvases; its tab opens a popover listing contents (up to ten most-recently-
  updated, with **Show more…** opening a folder-scoped search). Create one from the
  **+** at the end of the tab bar → **New folder**, then drag canvas tabs onto it.
  Right-click a folder tab to rename or archive; archiving a folder only removes
  the folder and returns its canvases to the top-level bar.
- **Choose the canvas type once** — document (narrative/hierarchy), database
  (items sharing a shape you want to filter/group/pivot), or folder (group
  existing canvases). The choice sticks.
- Keep order intentional: most-used canvases on the left, reference/archive on the
  right or in a folder.

### Organizing across spaces

- **Name spaces so they sort themselves:** prefix by domain (`eng-`, `design-`,
  `sales-`), use full words not initials, and reserve suffixes like `-leads` for
  restricted variants. Renaming is cheap and reshapes the sidebar for everyone.
- **Public by default, private by exception.**
- **Share canvases instead of duplicating:** right-click a canvas tab → **Share to
  space**, then pick any channel (or a DM you're part of). The canvas appears in
  both tab bars and edits reflect in both — one canvas, multiple locations. When a
  canvas lives in more than one space the menu offers **Remove from space** (only
  unlinks the current space); when it lives in just one it offers **Archive**.
- **Crosspost messages when a thread spans spaces** (see Spaces → Cross-posting).
- **Folders are a per-space view:** a canvas can be top-level in one space and
  nested in a folder in another, or in different folders in different spaces.
- **Hub spaces** gather cross-cutting topics (incidents, hiring) that span every
  team; link relevant canvases into the hub from each team's space.
- **Archive old spaces, don't delete:** an archived space becomes read-only, drops
  out of the sidebar and browse list, and stops collecting messages, but history
  is preserved and searchable. Reopening is reversible (a banner offers **Reopen
  channel**); a public archived channel can be reopened by any full member (who is
  then added), while a private one only by prior members. Guests can only reopen a
  channel they already belong to.

## Groups

A **group** is a named, invitation-only collection of people (and agents) that
makes two things easy: **notify a whole team with one @mention**, and **bring
people in together** by auto-joining a set of default channels.

- Groups appear in their own sidebar section, below Spaces and above Direct
  Messages. Selecting a group opens a **private feed only its members can see**.
- A group has a name (and optional description, icon, color), a member list of
  humans and agents, a members-only feed, and an optional list of **default
  channels**.
- **What groups are not:** they don't grant permanent channel access that's
  revoked on removal (joining a default channel creates a real, durable
  membership), and they don't replace spaces (the feed has no public/discoverable
  variant).

**Creating a group:** sidebar → `+ Group` next to the **Groups** heading → pick a
name, optional description and color → search and select people (you're added as
the **founder**) → "Create Group".

**Mentioning a group:** type `@` + the group name in any composer; groups you
belong to appear in autocomplete with a member count. Sending notifies every
member.

**Managing groups:** workspace admins manage every group from `Settings →
Administration → Groups` — **Members** (add/remove, set roles), **Default
channels** (add to bulk-join all current members; remove to stop new members
auto-joining, existing members stay), and **Archive** (soft-archive; feed becomes
read-only).

**Membership and roles**
- **Who can add/remove:** any group member can add another user (groups are
  intentionally self-growing); group **admins** can change roles and remove
  members; workspace admins/owners can manage any group. The founder is the first
  admin.
- **Adding** a member auto-joins them to every default channel. **Removing** a
  member is blocked if they're the last one (archive the group to dissolve it);
  removed members lose the group feed but keep memberships in default channels they
  joined via the group (an admin must remove them per channel).
- **Roles:** *Member* (post in the feed, mention the group, add other members);
  *Admin* (everything members can do, plus add/remove default channels, change
  roles, archive the group).

**Default channels** are a one-time bulk-join trigger, not a live link. Adding a
default channel inserts every current member; adding a member inserts them into
every default channel; removing either only deletes the link, leaving existing
memberships intact. Only group admins and workspace admins can edit default
channels, and to add a channel you must be able to post in it yourself.

**Privacy:** groups are invitation-only; names and metadata aren't exposed via
search or autocomplete to non-members.

## Messaging

Messages are the primary way to get things done in Monad.

**Composing and formatting**
- Open any space, click into the composer at the bottom, type, and press
  **Enter** to send (**Shift+Enter** inserts a newline).
- Markdown shortcuts: inline `**bold**`, `*italic*`, `` `code` ``, `~~strike~~`;
  blocks for ordered/unordered lists, blockquotes (`>`), code fences (triple
  backticks), and headings (`#`, `##`, `###`).
- Drag a file into the composer to attach it (images inline, other files as a
  download chip).

**Mentions** turn a plain message into a link that notifies someone or pulls in a
resource. Two triggers:
- `@` — **people, agents, broadcasts**: `@alice` (notify a teammate, link to
  profile), `@claude` (hand the message to an agent so it replies), `@design-team`
  (notify every group member), `@here` (notify everyone currently active in the
  space), `@channel` (notify every member). You only see people/agents/groups you
  have access to.
- `#` — **spaces, canvases, boards, tasks, threads**: `#design` (space),
  `#Project plan` (canvas document), `#Roadmap` (canvas database or board),
  `#Refactor onboarding` or `#DES-12` (task), and thread chips. Task chips show
  current status; picking any chip opens the resource in place.
- **Task search in the `#` menu** works by display id (typeahead, prefix-only:
  `#DES` lists the DES board, `#DES-12` narrows by number) and by title substring
  (`#refactor`). Archived tasks are hidden; you only see tasks you can access.
- **The Monad assistant is almost always available.** `@monad` appears in the
  mention list of every channel and group DM — even ones it isn't a member of. The
  only exception is a private one-on-one DM between you and another person. Monad
  sees exactly what you can see; in a shared room it only uses what everyone there
  can see (ask it in your private Monad DM when you need full context).
- **Who a mention reaches:** in a **public** channel, mentioning someone reaches
  them even if they haven't joined (that's how `@`-ing pulls them in); in a
  **private** space or DM, a mention only reaches people already in the room — add
  them as a member first.
- **Pasting a Monad link turns it into a mention chip** for spaces, canvases,
  agents, and threads (a reply URL becomes a "Reply in #channel" chip that jumps to
  that reply). Auto-conversion is skipped when the link reads as code (inside
  backticks or a code block) and falls back to a plain hyperlink if you can't see
  the target. (DM permalinks stay plain hyperlinks for now.)

**Threads**
- Every message can start a thread (hover and click the thread icon, or reply from
  the right-hand panel). Under a threaded message a small avatar row and a live
  summary appear — e.g. "2 replies · 1 active agent · 3 tool calls · 1 active
  sub-agent · Last reply just now" — each figure shown only when non-zero. On
  narrow screens it collapses to compact icons with counts.
- You automatically follow any thread you reply to or are @mentioned in.
- **"Also send to #channel":** a checkbox under the thread reply box posts your
  reply to the channel's main feed *and* the thread as one message. In the channel
  it shows a "replied to a thread" note; in the thread an "Also sent to the
  channel" marker. Off by default, decided per reply; if the thread spans multiple
  channels you get a row of channel chips (all on by default).

**Reactions**
- Hover a message and click the emoji button (on touch devices, tap the message to
  reveal its toolbar) to open the picker. The emoji appears as a pill with a count;
  click an existing pill to add yourself. Hover a pill to see who reacted (you show
  first as "You"). Click a pill you reacted to remove it. Reactions update live for
  everyone, everywhere messages appear (including threads and DMs).

**Custom emoji** work alongside built-in emoji. Type a colon and start a name
(`:part…`); custom emoji are listed first and render as small inline images.
Emoji-only messages render larger; animated emoji play automatically (a still
frame with reduced motion on). Removed emoji still show in old messages. Manage
them in **Settings → Emoji**.

**Attachments**
- Layout adapts to count and type: one file shows a single preview; two sit side
  by side; three show one large plus two smaller; four or more collapse to a
  preview with a thumbnail strip and a **+N** tile that opens the full gallery.
- Previews by type: images/video (with play button), audio (scrubbable waveform),
  PDFs (page preview), code/text (snippet), and a file icon for everything else.
- Hover any attachment for **Download**, **Copy link**, **Reply in thread**.
- The **gallery viewer** opens full-screen: step through with ←/→, play media,
  jump via the thumbnail strip, and download/copy-link/reply from the header; Esc
  closes.

**Editing messages**
- Edit your own messages for **24 hours** after posting (hover → **⋯** → **Edit**,
  change, **Enter** to save). A live **"Edited 2 minutes ago"** label appears
  (hover for the exact time). You can edit text, attachments, mentions, emoji, and
  formatting, but can't leave a message completely empty. New mentions added in an
  edit notify those people; already-mentioned people aren't pinged again. The same
  editing works on canvas-document and task comments. (Viewing earlier versions
  isn't available yet.)

**The composer companion** (optional, fun): a small pixel-art alpaca that perches
on the message box, tilts its head when you click in, peeks at your draft, and
celebrates when you send, teleporting to follow you between boxes. Off by default;
turn it on in **Settings → Preferences → Composer companion** (an account setting
that follows you across devices). Larger screens only; respects reduced motion.

## Direct messages

**Direct messages (DMs)** are private conversations outside any space — one-on-
one, a small group (group DM), or a mix of people and agents.

- **Starting a DM:** the **+** next to **Direct Messages** opens the **New
  message** dialog; pick people/agents and confirm. The DM is created immediately.
- **How DMs differ from spaces:** private by design (no public discovery, only
  participants see history), no member roles (everyone can post and react), and
  they **can have canvases** (a DM with a project canvas is great for coordinating
  a quick piece of work without a whole space).
- **Group DMs** (three or more participants) work like one-on-ones; the difference
  is stacked avatars in the sidebar. When a topic outgrows a group DM, start a
  dedicated space.
- **Messaging yourself:** every account has a private **self-DM** ("note to self")
  for personal notes, drafts, and links to revisit. It's created automatically and
  shows in the sidebar with your own name. To open one manually, pick yourself as
  the only participant — you always land in the same self-DM (no duplicates).
- **Notifications:** DMs notify you about every message by default; pause from
  **Settings → Notifications** if needed.
- DMs sync in the background; if the list gets stuck on a flaky connection it
  recovers on its own, shows a **Retry** link, and a full refresh always works.

## Tasks

A **task** is a tracked piece of work; tasks live on **boards**, and a board can
live on any space you can post to.

**Boards**
- A board is a Linear-style grid organized by status columns: **Backlog, Todo, In
  Progress, In Review, Done**, plus **Canceled** when filtered. Drag cards between
  columns to update status.
- Each board owns a **prefix** (2–8 characters, starting with a letter, unique
  across the workspace) chosen at creation. Tasks are numbered with it (`ENG-12`),
  so `#ENG-12` always resolves to the same task.
- Create a board by opening a space, clicking **+** next to its tab bar, picking
  **Board**, giving it a title, and choosing the prefix.
- **Drag-and-drop reordering** works within a column (drop between cards) and
  across columns; each board keeps its own order, broadcast live to every viewer.

**Creating and editing tasks**
- Create from any board: click **+** on a column header or the quick-add bar, type
  a title (`⌘↵` / `Ctrl+↵` submits), and optionally set status (defaults to
  **Todo**) and priority. The task gets the next `{prefix}-{N}`. The board you
  create on becomes the task's **default board** (the id shown without board
  context — notifications, bare mentions, permalinks).
- Click a card to open the detail modal. Title and description edit inline (edits
  within ~2 seconds collapse into one audit entry). Status, priority, and assignee
  are in the right-hand property panel. **Labels** come from a workspace-shared
  catalog managed in `Settings → Administration → Task labels`. A **Definition of
  Done** checklist below the description tracks acceptance criteria (checking a row
  strikes it through). These properties are the same wherever the task appears —
  only the id and column position are per-board.
- **Sub-tasks:** click **+ Add sub-issue** to create a child task. Sub-tasks are
  their own cards carrying a small `↳ PARENT-N` label; the parent card shows a
  sub-task count you can click to open and jump. A child can live on a different
  board (sharing a parent doesn't auto-share children).

**Sharing a task across boards**
- A task can appear on as many boards as you can add it to (detail modal → side
  panel → **Boards** → **Add to board**). On each board it gets that board's own id
  (`ENG-12` on engineering, `DES-4` on design) — both ids open the same task.
- Opened from a board, the header shows that board's id with pills linking to its
  ids on other boards; opened without board context it shows the default board's
  id. **Unsharing** removes it from a board but the old id keeps resolving forever
  (links and `#`-mentions never break); the number is never reissued.
- A task always stays on **at least one board** — to take it off its only board,
  **archive** it instead (detail modal → `⋯` → Archive). Archived tasks leave the
  default board view but stay reachable by direct link, search, and `#PREFIX-N`.

**Comments, mentions, and the audit trail**
- Each task has a comment thread using Monad's standard messaging machinery:
  mentions (`@user`, `#space`, `#PREFIX-N`, `@here`, `@channel`), reactions, read
  cursors, and **Resolve** (an admin or thread starter can resolve; resolution
  requires the `task:resolve_comment` permission, broader than posting). Edit your
  own comment for **24 hours**.
- `#PREFIX-N` mentions (case-insensitive) work anywhere — in messages, comments,
  and canvas documents — rewriting to a link with a lazy-loading **hover-card**
  showing title and status. Any of a task's ids works; freed ids still resolve.
- Every task has a stable permalink (header `⋯` → **Copy link**); pasting it turns
  into a clickable task chip.
- The detail modal's **Activity** section is a per-task audit log of every change
  (status, priority, assignee, labels, sub-tasks, board shares/unshares, and
  debounced title/description edits), following the task wherever it's shared.

**Subscriptions and notifications**
- **Subscribe to a task** (header **···** → **Subscribe**) to get its status and
  assignment changes in your Activity feed. You're auto-subscribed when assigned,
  when you create a task, or when you comment; unsubscribing sticks.
- **Subscribe to a board** (the bell in its toolbar) to be notified about activity
  on every task on it — new tasks, assignee/status/priority changes, and shares
  on/off the board.
- You're notified when a task is assigned to you, when a subscribed task's status
  or priority changes, when you're @mentioned in a comment/title/description, and
  on replies to threads you're in — but never for your own changes. Group
  @mentions in a comment notify the whole group (use sparingly).
- Read access to a task implies read access to its comment thread (there's no
  comment-only tier), so keep a sensitive task's board in a sensitive space.

**Common patterns:** an engineering team runs a standing `ENG` board on its space;
a cross-team initiative runs a `Goals` board on a workspace-wide space with tasks
shared in from each team; an onboarding checklist is a task with a
Definition-of-Done plus sub-tasks for items big enough for their own thread.

## Canvas documents

A **canvas document** is a rich-text page living inside a space, right next to the
channel. Use it for meeting notes, runbooks, specs, design docs, and decision
records.

**What makes them different from a generic doc editor**
- They live with the conversation (same view as the channel and agents).
- They're real-time collaborative — several people and agents edit at once, with
  live cursors and clean CRDT merges (built on Tiptap/ProseMirror with a Loro-CRDT
  binding), no "someone else's changes" overlay.
- You can comment anywhere — on a highlighted phrase, a whole block, or the page.
- AI agents can read and edit them; contributions are color-coded by author.
- Documents inherit access from the space they live in (anyone who can read the
  space can read and edit its documents; no separate per-document permission).

**Block types** (via the `/` slash command, the block menu, or markdown
shortcuts): paragraph; Heading 1/2/3; bulleted, numbered, and task lists (checking
a task item strikes it through); blockquote; syntax-highlighted code block (~30
languages via lowlight); horizontal rule; image; file attachment; table (with
concurrent cell editing); toggle/collapsible; callout (10 color variants + emoji);
columns (`/2 columns`, `/3 columns`; stack on mobile; resize/drag-between not yet);
bookmark/link card (fetches and snapshots OpenGraph metadata so it stays stable);
and block-level math equations (LaTeX rendered with KaTeX; inline `$x$` not yet).

**Inline formatting (marks)** via a bubble menu or shortcuts: bold (`Cmd/Ctrl+B`),
italic (`+I`), underline (`+U`), strikethrough (`+Shift+S`), inline code (`+E`),
highlight in six colors (`+Shift+H`), subscript/superscript (`+,` / `+.`), links
(typing/pasting a URL auto-wraps; paste onto a selection to wrap it), and Comment.
Other niceties: hex color swatches render next to a typed hex code; an emoji picker
(`:name:`) inserts built-in emoji as unicode and custom emoji as inline images;
**find and replace** (`Cmd/Ctrl+F`, then `+Shift+F`).

**Mentions** inside a document mirror the message composer: `@` for people/agents
(group mentions not yet supported in documents) and `#` for spaces, canvas
documents/databases, boards, and tasks, with the same paste-to-chip behavior.

**Comments** can be started three ways: page-level (top of the document), block-
level (drag-handle menu → Comment, stays attached even on empty blocks), and
substring-level (select text → speech-bubble; the selection gets a colored
underline you can click to return). Threads display as a floating popup with
**Show all comments in sidebar**, **Resolve**, and **Close**; archive a thread from
its **⋯** menu. The sidebar lists open and resolved threads with an `N open · M
resolved` header. Anyone who can edit the document can resolve; archiving is
restricted to a workspace owner/admin, the document owner, or the thread starter.
A meta-bar **Subscribe** turns on the document bell (new comments and content
changes notify you even if you've muted the space).

**AI inline autocomplete:** after a brief pause at the end of a paragraph, Monad
shows a dimmed rainbow ghost-text continuation. **Tab** accepts; **Esc**, any
keystroke, or moving the cursor dismisses; pausing again requests a fresh trio.
Three sizes — **Sentence** (default), **Paragraph**, **Section** — and you cycle
with **Alt+↓** (longer) / **Alt+↑** (shorter). Nothing is inserted automatically,
and the suggestion is a private preview until you accept. It fires only in plain
prose paragraphs (not lists, headings, code, or table cells) and is toggleable per
document; the per-user default is **on**.

**Authorship colors:** every text run records who typed it. **Off by default**;
turn on via the **⋯** menu (per-document, with a per-user default that starts off).
Each contributor gets a stable color from a 14-entry palette; the document
creator's text uses the default prose color (so the page isn't drowned in color);
AI-authored text renders in a rainbow gradient.

**Version history:** save labeled versions (page menu → **Version history** →
**Save version**), kept forever; **autosaves** stamp every ten minutes of editing
and are kept 30 days. Browse versions newest-first, **View** a read-only preview,
and **Compare** two (Shift-click to anchor, Shift-click another) to get a
structural diff — green for added text, red strikethrough for removed, amber for
formatting-only, and labeled cards for whole blocks added/removed/moved.
**Revert** jumps the whole document back for everyone immediately (anyone editing
is reset with a banner; reverts are append-only, so you can revert a revert).

**Offline editing:** once a document has been opened online, the browser keeps a
local copy (via the Origin Private File System), so reopening, switching between
documents, and editing all work offline; queued edits flush on reconnect, and two
tabs can edit the same document with CRDT merges. A status pill shows the state
(Live, Connecting…, Reconnecting…, Offline — changes will sync, etc.). If a
teammate reverts while you have offline edits queued, on reconnect you choose
**Keep my edits** or **Discard my edits**. Older browsers fall back to in-memory
storage (edit online only). Local state is scoped per tenant subdomain.

**Sharing and export:** the meta-bar **⋯** menu (or right-clicking the tab) offers
**Copy share link** — a link, not an invitation, that opens the document for anyone
who can reach it through any space it's shared into (recipients without access see
a not-found page). Export a document to **Markdown** (with YAML frontmatter:
title, description, icon, author, created, spaces) or **PDF** (title/author/date
header, embedded inline images). A **page icon** (emoji) sits above the title and
replaces the default tab icon.

## Canvas databases

A **canvas database** is a structured table of records living inside a space, next
to the channel and document canvases. Each row is a record with **typed cells**,
and the same data can be shown through multiple **views** without copying.

**When to use one:** anything you'd track in a spreadsheet where rows are things
you'll talk about, assign, filter, or cross-link — projects, tasks, OKRs, sprints,
customer accounts, leads, tickets, bug reports, content pipelines, inventory,
hiring. If the data is mostly free-form prose, use a document instead.

**Creating:** open a space → **+** in the canvas tab bar → **Database**. It starts
with no columns and one default **Table** view. Set a name, an emoji icon, and a
description at the top; everything saves automatically and syncs in real time.

**Column types (16 kinds):** String (free text, optionally rich-text Markdown,
capped at 256 KiB/cell), Integer, Decimal (declared precision/scale), Boolean
(checkbox), Timestamptz, Date range tz (a start/end pair, exposing hidden
`__start`/`__end` sub-columns), Enum single-select and multi-select (each option a
label + color from a 9-entry palette; create options inline by typing a name and
Enter; empty cells show `—`), URL, Email, User (a workspace member shown as
avatar + name, picked from a searchable list), Attachment, Canvas object ref
(pointer to another canvas), Database relation (typed link to another database,
cardinality one or many), Formula (computed), and Dynamic (unknown payload type,
useful during import; narrow later with Strict / Coerce best-effort / Coerce or
null policies, keeping an audit trail).

**Rows and cells:** add a row with **+ Row**; click to focus, type/Enter/F2/
double-click to edit (Enter commits, Esc cancels, Tab commits and moves right);
select ranges (Shift+click or Shift+arrows), whole rows (row gutter), or whole
columns (header); drag headers to reorder; **copy/paste** as plain text or TSV
(values coerced to each column's kind, uncoercible cells skipped); **Delete**
clears cells (formula columns skipped); deleting rows soft-deletes them
(restorable via version history). The **row detail dialog** (chevron at the start
of a row) shows every column as a labeled field — handy for many-column rows and
kinds the grid can't inline-edit. Every row tracks who last modified it and when.

**Filters and sorts** are stored per view. Operators form a closed catalog with
the same semantics in server SQL and client offline replay: `eq`/`neq`,
`gt`/`gte`/`lt`/`lte`/`between`, `in`/`not_in`, `contains`/`not_contains`/
`has_member`/`not_has_member`/`set_eq`, `starts_with`/`ends_with`, and
`is_null`/`is_not_null`. Filters compose with AND/OR groups (negate at the
operator). A visual builder produces schema-valid filters that round-trip with the
agent's `select_rows` tool and the API.

**Views (five kinds):** each has its own filter, sort, visible columns, and column
widths.
- **Table** — the default columnar grid; best for bulk editing and dense data.
  Column order is shared across views; widths are per view.
- **Board** — kanban lanes grouped by an enum column; drag rows between lanes to
  update the value; reorder lanes to set the option order everywhere; rows without
  a value land in a "No Value" lane.
- **List** — a vertical list, optionally grouped; best for prioritized reading and
  weekly review.
- **Gallery** — cards with an optional cover image column; best for visual content.
- **Feed** — a chronological stream; best for activity logs and timelines.
Add a view from the **+** next to the view tabs; rename by double-clicking the tab.
A row update appears in every view that includes it (and disappears from a view
whose filter now excludes it).

**Comments** anchor at four levels of precision — the database as a whole, a row, a
cell, or a substring inside a rich-text cell (preserved across edits). Open threads
from the row detail dialog or the cell editor; replies/resolve/unresolve work like
document comments. When creating a thread you can **cross-post the root message** to
one or more spaces (it appears as a normal channel message quoting the anchored
text with a link back; replies stay scoped to the thread). A **Subscribe** bell
follows the database for updates and new comments.

**Version history and collaboration:** every operation is a **revision** with a
kind (schema, data, view, comment, revert, narrowing, formula_recompute). Revert a
single revision or a range (compensating revisions are appended, so you can revert
the revert), and use the revision list as an audit log. The database is
generation-aware: reverting a range bumps the generation and flags in-flight edits
against the old generation for resolution via a dialog. Offline edits queue and
replay against the latest server head; a header pill shows live/syncing/connecting/
disconnected, and a conflicting revert prompts retry/discard/review.

**Formulas** compute a value from other columns in the same row (e.g.
`[@Status] = "Done" && [@DueDate] < now()`). References use `[@Name]` but compile
to a stable AST keyed on column id (renaming a column doesn't break the formula); a
formula declares its return type and is marked broken with a clear reason if a
dependency no longer fits; supported operations include arithmetic, booleans,
comparisons, `if`/`and`/`or`/`not`, `concat`, aggregates (`sum`, `count`, `min`,
`max`, `avg`), and coercions; cycles are rejected. (Cell-level formula overrides
and filtered rollups are planned but not yet shipped.)

**Working with agents (structured tools, not raw SQL):** agents refer to columns
by name and dropdown options by label, so "set Status to Done for everything in
this sprint" just works. Shipped tools include `describe_database`, `select_rows`
(structured filter DSL with order/limit/cursor/projection), `insert_rows` (up to
1000), `update_rows` (each row by a unique field), `bulk_set_rows` (one field to
one value across a filter), `bulk_delete_rows` (soft-delete up to 1000),
`add_column`, `rename_column`, `drop_column`, and `revert_database_revision`. The
surface is type-checked end to end, and bulk gates protect against a mistaken
filter destroying thousands of rows. Typical asks: "create a database to track our
quarterly OKRs with columns for Owner, Status, Quarter, and Target Date"; "add the
bug we just discussed with severity High and owner @alice"; "which projects are
still in Backlog past their due date?"; "undo my last update."

**Export and sharing:** the page **…** menu offers **Export to CSV** (matching the
selected view's visible columns, order, filter, and sort, with a leading
apostrophe on values that look like formulas so Excel/Sheets don't misread them)
and **Copy share link** (opens the database on its default view for anyone who can
reach it through any space it's shared into). Databases inherit space access (read
implies edit; only owners/admins or a linked-space admin can delete the canvas; no
per-row/per-column permissions yet). A database mention chip carries a Circle Stack
icon and a **Database** badge.

## AI agents

An **agent** is an AI teammate that is a first-class member of the workspace, with
a handle, profile, permissions, and access to the same conversations and canvases
as humans. Agents are framed as proactive coworkers — "virtual employees who keep
up with their channels" — not bots you have to summon.

**What agents can do**
- Read and reply in spaces and DMs they're members of.
- Use tools — search the workspace, query and edit canvas databases, edit canvas
  documents, search and read the web, post to other spaces, and call external
  systems via MCP.
- Remember — every agent has long-term memory that persists across runs, plus a
  per-session scratchpad for in-flight notes.
- Delegate to sub-agents for specialized work.

**Talking to an agent:** @mention it like a person (it joins the thread, runs
steps, and posts back, keeping context in the thread), DM it directly, or put it
on a recurring schedule. Hover an agent's name in the **Agents** sidebar list to
see its description card. Agents also check in on their own from time to time.

**Proactivity:** a channel-member agent sees new messages without being mentioned
and decides whether to step in — replying when a message is clearly in its area or
names it, staying quiet for small talk, side conversations, or questions aimed at a
specific person. To stop proactive chiming-in, remove the agent from the channel
(finer-grained "stay but only reply on @mention" control isn't available yet). A
new agent starts as a member of the workspace's default spaces; add or remove it
from other spaces like a human.

**The built-in Monad assistant** works differently from created agents: it's
available in every channel and DM without being added (`@monad` anywhere), doesn't
show in member lists or take a seat, and pins your DM with it to the top of your DM
list. Its key rule is that it sees exactly what *you* can see and nothing more —
true even for workspace admins — and in a shared room it only draws on what
everyone there can see (pointing you to your private Monad DM when it needs your
full context). Shape how it works with you in **Settings → Preferences → "How Monad
works with you."** It can't be deactivated, because it powers core features like
creating new agents.

**Rating responses:** every agent message has a 👍/👎 bar (hidden until hover on
desktop, always visible on touch). Clicking saves the rating immediately; you can
add a sentence about why, switch your vote, or click the same thumb to remove it.
Only you see how you voted.

**How agents improve over time (prompt optimization):** every couple of days each
agent reviews its recent answers and your feedback; a powerful "teacher" model
decides what the ideal answer would have been and rewrites the agent's instructions
to close the gap. Improvements apply automatically only when they clearly do better
without making other answers worse, and every change keeps the previous version
(one-click rollback); switch an agent to **review-first** to approve changes.
Managed in **Settings → Agents → Optimization → Prompt optimization** (admins).

**Overnight memory tidying:** once a night, during quiet hours, an agent
consolidates what it learned — merging duplicates, resolving contradictions
(keeping the newer/more reliable version), tightening verbose notes, and retiring
stale ones (set aside, never deleted, and restorable). It can also propose a small
one-line fix to its instructions when the day's conversations clearly overtake a
line (held for approval by default; switch on auto-apply to take effect
immediately, always revertible). Tidying happens one memory area at a time so
private and shared notes never mix. The nightly run is the **master switch** —
turning it off also pauses that agent's prompt optimization (they share the pass).
Managed in **Settings → Agents → Optimization → Memory & nightly fixes**.

**Skills:** a skill is a reusable set of instructions written once that every agent
in the workspace can use; agents load it only when a task matches. Create one in
**Settings → Skills → New skill** with a Name, a one-line Description (the only
thing an agent sees until it loads the skill), an optional "When to use" hint, the
full Instructions in markdown, and optional Plugins. **Inherited skills** ship free
with every workspace (read-only; override by creating your own with the same name).
You can ask an agent to "turn that into a skill the team can reuse" after a
multi-step task you liked (saved live with an agent badge). Every edit is kept in
**History** with a source badge (human/agent/imported) and is revertible; you can
disable a skill (keeps it in the list) or delete it (frees its name). Import and
export use the common `SKILL.md` format. Any member can manage skills.

**Scheduled tasks:** a standing instruction Monad runs automatically on a schedule
— **as you, using your connected apps**, delivered privately to your DM with Monad
(no one else sees it). Set one up by asking Monad in your DM, or from **Settings →
Account → Scheduled tasks → New task** (name, instruction, schedule, timezone).
Manage them there with **Run now**, **Pause/Resume**, and **Delete**. Tasks run in
your timezone (automatic daylight-saving adjustment is coming soon), at most every
15 minutes; if a needed app isn't connected, Monad DMs you to reconnect rather than
failing silently. (This differs from Monad's automatic check-ins: a scheduled task
is a specific instruction on a cadence you chose.)

**Managing an agent (if you manage it):** open the agent's page → **Configuration**
tab.
- **Change the handle** in the Handle field → **Change** → confirm. The previous
  handle is reserved for one year (existing links/@mentions still lead to the
  agent); there's no waiting period between agent handle changes, and old page
  links keep working.
- **Deactivate** at the bottom (→ confirm) to fully turn the agent off — it stops
  responding to @mentions, followed-channel activity, and scheduled tasks, and is
  hidden from people and pickers; in-progress work wraps up its current step. Past
  messages, profile, and memory are kept. Find deactivated agents in **Settings →
  Agents** and **Reactivate** them (scheduled tasks aren't restored automatically).

## Notifications and the Activity feed

Monad routes notifications based on **why** something deserves attention, not just
which channel produced it.

**What triggers a notification**
- **Mentions** — a direct @mention, or `@here`/`@channel` in a space you're a
  member of (`@here` pings only members currently online; `@channel` pings every
  member).
- **Direct messages** — every new DM by default.
- **Thread replies** — replies in a thread you follow (replying or being
  @mentioned starts following).
- **Task updates** — a task assigned to you, or a subscribed task's status,
  priority, or assignee change; subscribe to a task or a whole board.
- **Reactions to your messages** — grouped into one item per message; reacting to
  your own doesn't notify, and muting the space silences them.
- **Agent activity** — when an agent you own finishes a run.
- Routine activity in spaces you're a member of but not involved in just bumps the
  unread count.

**Per-space tuning:** each space has a **bell** at top right with three settings —
**All new posts**, **Just mentions** (the default for channels), and **Mute** (only
bumps the unread count). The choice is yours alone and applies only to that space.

**Where notifications appear:** in-app (Activity feed and unread badges, always
on); **push** (web push on desktop and mobile browsers, and on iOS/Android when
Monad is installed as a PWA, which then shows an app-icon badge); and an optional
**email digest** (daily or weekly). Tune push, sounds, and global mute in
**Settings → Notifications**.

**Suppression:** Monad skips a push when you're actively viewing the source on any
signed-in device, when the message is from you, or when you've muted all
notifications or turned push off. With multiple devices, push goes to recently-
active ones; if you're fully offline it only reaches devices where Monad is
installed as a PWA. You can send a test notification (which skips the usual
suppression). Quiet hours aren't available yet.

**The Activity feed** (the **Activity** sidebar item) is a working list, not a
permanent log. It shows replies in followed threads (collapsed per thread as an "X
new replies" row), mentions, DMs, canvas updates and comments, task updates, and
space changes (like being added to a space).
- **Read vs. archive are separate:** reading **fades** an item (lighter, dimmed)
  but it stays in the list; **archiving** removes it. Mark read by clicking it
  (which jumps to the first unread thing), using the row's check button, or reading
  the source. Archive with the row's archive button — but if something new happens
  later, the item comes back automatically (archiving doesn't mute). Archiving
  isn't undoable and there's no archived view; use **Snooze** when you want
  something to return on its own (5 minutes, 30 minutes, 1 hour, 1 day, 1 week).
- Scrolling doesn't mark things read. The header offers **Mark all read** and a
  **⋯** menu with **Settings** and **Get local notifications** (browser permission
  + this-device subscription). Everything updates live.
- **Two kinds of unread badge:** the **Activity badge** counts unread *items* (a
  thread with seven replies is one item), while **space/DM/group badges** count
  only new messages in that channel's main feed (thread replies are tracked
  separately and don't add to a space's badge).

Agents work from the same shared activity humans see, which is what makes an agent
a proactive coworker rather than an @mention-only bot.

## Integrations and MCP

Monad connects to your stack three ways: link previews, MCP servers (let Monad's
agents call your other tools), and MCP access from other AI apps (let Claude or
ChatGPT read and write in Monad on your behalf).

**Link previews:** paste any link into a message to get a rich preview (title,
description, site name, thumbnail) generated from the page's public metadata.

**MCP servers (Model Context Protocol):** MCP is an open standard connecting AI
agents to external tools (warehouse queries, help-desk tickets, deployments —
anything an MCP server exposes). A workspace admin adds servers under **Settings →
Agents → Connections**, each with a URL, optional custom headers (for API
keys/auth), and an enabled/disabled toggle; enabled servers' tools become available
to agents. You can turn individual tools on/off from a server's detail page (click
**Test** to list them; off tools appear in a **Disabled tools** list with who/when;
new tools start on). If a server expects per-user credentials, each member sets
their own under **Settings → Account → Connection Preferences** (personal credentials
override workspace defaults when an agent acts on that user's behalf).

**Your own MCP servers** (private to you, under **Settings → My Connections**):
add a personal automation, a Zapier endpoint, or a self-hosted tool without waiting
for an admin — only agents acting on your behalf can use them. Provide a display
name, URL, optional description, and an auto-suggested slug, then choose
authentication: **Headers** (static API key/bearer token, one row per header, sent
with every request, stored encrypted) or **OAuth** (a sign-in flow you complete by
clicking **Connect**; Monad registers with the server from its URL — no client
details to copy; a green **Connected** or **Reconnect needed** badge shows status).
Renaming a slug holds the old name for 24 hours. Servers and credentials are
visible only to you.

**Connecting Gmail:** some integrations need your account, not a shared key. Two
ways to set it up. If an admin enabled Gmail (Connectors on the Connections page),
find Gmail under **Settings → Connection Preferences**, click **Add**, and on the
connector's page click **Connect**, sign in with Google, and you get a green
**Connected** badge. Once connected, the card dims to an **Added** tile and the
connection appears in your Connections list above, where you manage or disconnect it. Or do it yourself with no admin: under **Settings → My
Connections → Connectors**, click **Add** on Gmail to open its page, then under
**Use it with your own account** create a Google OAuth client (register the redirect
URI shown), paste its Client ID/Secret, and **Add & connect** — it's installed as
your own private connection and connected as you. Then ask an agent "summarize my unread
email" or "draft a reply to Sam." Agents can read and compose mail only. An amber
**Reconnect needed** badge means access expired or permissions changed. Disconnect
anytime. Your connection is yours alone; admins see only *that* you've connected
(for auditing), never your mail or tokens.

**Connecting X (Twitter):** X needs your own developer app. Under **Settings →
Agents → Connections → Connectors**, find **X (Twitter)** and click **Add** to open
its page; under **Your account**, if an admin already set it up click **Connect**,
otherwise create an OAuth 2.0 app in the X developer portal, register the callback
shown, and paste the Client ID/Secret, then **Save & connect**. Once connected your
agents act as your account — read (search, look up users and posts singly or in
batches, read timelines, and check your mentions) and, when you ask, post, reply,
repost, like, follow, and delete. They can also keep a set of people in an X List
and scan everyone's recent posts in one pass. Posts, replies, reposts, and follows
are public and immediate, and deleting a post is permanent. An admin can instead
bind one shared corporate X account for everyone. Disconnect anytime.

**Use Monad from Claude:** Monad ships an inbound MCP endpoint, so Claude (desktop
or iOS) can send messages and replies, read recent conversations, search across
messages/spaces/documents/people/files, create and edit canvas documents and
databases, file and comment on tasks, and read help articles — all acting as you
with your permissions and audit trail. In Claude desktop: **Settings → Connectors →
Add custom connector**, enter your Monad MCP URL
`https://<your-workspace>.onmonad.io/mcp`, sign in to Monad in the browser, and
approve the consent screen. On Claude iOS, add the same URL under **Settings →
Connectors → Add server**. Revoke from **Settings → Personal → API keys & apps** in
Monad (find the "Claude" row → **Revoke**).

**Use Monad from ChatGPT:** the ChatGPT app supports MCP servers. Turn on **MCP
servers** under **Settings → Beta Features**, then **Settings → Connectors → Add MCP
server**, enter `https://<your-workspace>.onmonad.io/mcp`, sign in to Monad, and
approve consent. ChatGPT can then do anything you can, attributed to your account.
Revoke from Monad's API-keys page or inside ChatGPT (Disconnect).

**Personal API keys:** for a script/CLI that acts as you (when an OAuth flow isn't
practical). Mint one in **Settings → Personal → API keys & apps → New API key**;
the plaintext key is shown once (copy it then — Monad never shows it again). Use it
in the `Authorization: Bearer <your-key>` header on requests to the MCP endpoint.
Keys minted from Settings carry the **`mcp` scope only**. Revoke from the same page
(takes effect on the next request).

**Sessions, grants, and activity:** the Sessions panel under **Settings → Personal
→ API keys & apps** is the one place to see and revoke anything that can act as you
— **browser sessions**, **personal API keys**, and **connected apps** (OAuth grants
for Claude, ChatGPT, etc.). Each row shows identifying details, when access was
granted, and when it was last used. **Revocation is permanent** (mint a new key or
repeat OAuth to restore). Each app/key row has an **Activity** link to a paginated
history of every tool call (name, timestamp, success, duration); arguments are
summarized — Monad deliberately doesn't keep a full copy of every message body or
canvas edit sent through MCP.

**Web search and reading:** when an agent's `web` tools are on, it can search the
public web (a ranked list of links), read a page (clean main text, ads/nav
stripped), or read several pages at once. By default a page may be served from a
short-lived cache (up to two days old); ask the agent for an up-to-date copy to
fetch fresh. Agents treat web content as **untrusted** (used to answer, but
instructions hidden inside a page are ignored). Web usage is metered and billed to
your workspace (shown under **Web Usage**); you can bring your own **Firecrawl** key
(starts with `fc-`) in **Settings → Billing → Web search & reading key** so
Firecrawl bills you directly and Monad adds only its surcharge.

## Settings, billing, and administration

**Your profile and account** (**Settings → Account → Preferences**): your
**display name**, **handle** (`@you`, unique per workspace), **avatar** (uploaded
PNG/JPEG/WebP up to 5MB, or a generated gradient), **role**, and **time zone**
(auto-detected until you set it; shown on your profile so teammates and agents know
when you're awake, and used to schedule your recurring agent tasks). Set a
**translation language** so foreign-language messages auto-translate as they scroll
into view. **Security** (**Settings → Account → Security**) lists active sessions
and passkeys — revoke individual or all other sessions, and add/remove passkeys for
passwordless sign-in.

**Changing your handle** (**Settings → Preferences**): type a handle (availability
shows as you type; lowercase letters, numbers, hyphens) → **Change** → confirm.
Your old handle is reserved for you for one year (links/mentions still lead to you;
you can switch back). Past mentions update to your new name automatically. You can
change your handle once every 30 days.

**Inviting people** (**Settings → Members → Invite people**): add emails, pick a
**role** for the batch (**Member, Admin, or Guest**), and optionally pre-pick the
**spaces** and **groups** they join. The spaces picker offers Suggested chips (often
`#general`/`#random`) and a **Suggest with AI** option (describe the person and
Monad picks matching spaces). Invitees get an email with a setup link; the joins
happen when they accept and finish setup — landing in default channels, every
pre-picked space, and every pre-picked group (with its feed and default channels),
plus a welcome DM from Monad. Pre-picking is per batch, not per person.

**Guests:** a guest has limited access to just the channels you add them to — for
clients and contractors — and is **free** (never counts toward paid seats). Add one
from **Settings → Members** with the **Guest** role and chosen channels. Guests can
read, post, react, and search in their channels, and chat with agents present
there (and with the Monad assistant in their Monad DM), but can't see or join any
other channel (even public ones), see or message people they don't share a channel
with, land in default channels, add anyone else, or create channels/groups/agents/
emoji or connect outside accounts. Add them to more channels from a channel's member
list; remove access by removing them from a channel or the workspace.

**Guest invite links** (**Settings → Guest links → Create link**): a single
shareable URL that drops anyone into chosen channels as a free guest. Set a Name
(for you), the **Channels** they join, and optional **Require admin approval**,
**Bot challenge**, **Max uses**, and **Expires**. The URL is shown once. When
someone uses it, a new person verifies their email and becomes a guest; an existing
signed-in member just gets the channels added (role unchanged); an existing email
is asked to log in first. Approval-required links queue requests under **Pending
requests** for any admin to Approve/Reject. **Revoke** stops new joins (already-
joined guests stay).

**Workspace settings** (**Settings → Administration → Workspace**, owners/admins):
change the **logo** (PNG/JPEG/WebP up to 5MB, square looks best), the **name**, and
the workspace default **timezone** (used for scheduled/agent tasks not tied to a
person). The workspace **address** (URL) is shown but can't be changed here. The
**owner** sees a **Danger zone → Delete workspace** (admins don't); deletion is
immediate and permanent (everyone is signed out, everything is removed, no
recovery) and requires typing the workspace name to confirm.

**Custom emoji** (**Settings → Emoji**): upload a PNG/GIF/JPEG up to 256 KB
(animated GIFs work), name it with letters/numbers/dashes (lower-cased
automatically, unique, not matching a built-in name). Add **aliases** (a second
name for the same image), rename, or remove (history keeps the picture). By default
anyone can add; an admin can restrict it to admins.

**Choosing a model tier:** when you create or edit an agent you pick a **tier**
rather than a specific model — **Frontier** (highest capability), **Balanced** (the
default for new agents), or **Cost-Effective** (fast and economical) — each shown
with a price per million tokens and improvable over time without changing what you
pay. **Enterprise** unlocks pinning a specific model (and fallback) via the
**Advanced** option (billed at provider cost plus a 30% markup) and bringing your
own keys.

**Bring your own OpenRouter key (BYOK, Enterprise only):** by default inference
runs on Monad's OpenRouter key, billed at the model tier price. Add your own key
(starts with `sk-or-`) in **Settings → Billing → AI inference key** to pay
OpenRouter directly; Monad then bills only its margin (tier price minus your raw
cost, never below $0). Keys are stored encrypted and never shown back in full; a
freshly-saved or removed key takes up to ~120 seconds to apply across all workers.
Most user-initiated inference uses your key (agent runs, classification, OCR and
transcription run by agents, canvas autocomplete, translation, semantic search, the
reranker); a few background paths (the search indexer, attachment text-extraction,
and some `@mention`-ranking embedding caches) stay on the platform key by design.
Only members with **Manage billing** can change it.

**Plans and billing:** every workspace is on **Plus** (prepaid credit; the starting
plan; begins with **$50 free welcome credit**), **Pro** (pay-as-you-go, monthly
invoice), or **Enterprise** (pay-as-you-go plus bring-your-own-key). Plan changes
are arranged with Monad, not in-app; any plan can open **Manage Billing** from
**Settings → Billing** to update payment and view invoices. On Plus, credit is
drawn down by agent replies and actions, web search and page reads, and document
understanding/search indexing — each shown in **Recent activity**. Welcome and
purchased credit expire one year after they're added (purchased credit is used
last); a monthly allowance, if any, is use-it-or-lose-it. Top up with a minimum
$20. **Auto-recharge** (Plus) keeps the balance topped up: save a card, set
**Recharge when below** (min $5) and **Add this much** (min $20, more than the
trigger), and turn it on.

## Apps and offline

**The Mac desktop app** adds tabs (⌘T new, ⌘W close, ⌃Tab switch), multiple
signed-in workspaces (each with its own tabs), native macOS notifications with a
Dock badge, and a graceful offline screen. Download the `.dmg`, drag **Monad** into
**Applications**, and open it (it's signed and notarized). Enable notifications even
when the app is closed via **Settings → Notifications → Push Notifications → Turn
on**. The app prompts for updates (install now / remind later / skip), with optional
automatic updates, and works offline (already-opened canvases keep working and sync
on reconnect).

**The iOS app** (iPhone/iPad) adds push notifications (mentions, DMs, thread
replies — with custom emoji shown in the banner, and an app-icon badge for your
active workspace), deep linking (tapping a Monad link from Messages, Mail, or
anywhere opens that exact view, switching workspaces if needed), and an offline
screen that reloads automatically. Install from the App Store, allow notifications,
and sign in with the same account as the browser; change which notifications you get
in **Settings → Notifications**.

**Offline, everywhere:** canvas documents and databases are built for flaky and
offline connections — local snapshots, queued edits, status pills, and automatic
sync on reconnect — so work is never lost (see Canvas documents → Offline editing
and Canvas databases → Version history and collaboration).

---

# Next steps

- **Try Monad:** create a workspace at https://onmonad.io and let the AI setup
  wizard build your channels, docs, a database, a board, and a starter agent with
  you. You start with $50 of free AI credit and no card required.
- **Read the help center:** https://onmonad.io/help — every feature above has a
  matching article, organized by Getting started, Spaces, Groups, Tasks, Messaging,
  Canvas documents, Canvas databases, Agents, Direct messages, Notifications,
  Settings, and Integrations.
- **Connect your AI app:** add Monad as an MCP connector in Claude or ChatGPT using
  your workspace MCP URL `https://<your-workspace>.onmonad.io/mcp`, and let it read,
  search, and post on your behalf. For scripts, mint a personal API key under
  **Settings → Personal → API keys & apps**.
- **Set up an agent that works while you sleep:** in your DM with the Monad
  assistant, ask for a scheduled task ("every weekday at 5pm, draft replies to
  anything urgent in my inbox"), connect Gmail under **Settings → MCP
  Preferences**, and rate its replies 👍/👎 so it improves.
- **Bring your team:** invite people by email or hand out a guest link, pre-picking
  the spaces and groups they should land in.
- **Compare Monad to your current stack:** head-to-head pages live under
  https://onmonad.io/compare/ — one per tool: slack, microsoft-teams, notion,
  airtable, asana, clickup, monday, glean, and chatgpt-team.
- **Questions or trouble?** Email support@onmonad.io.

---

This file is a hand-maintained, plain-text overview of Monad for large language
models and automated readers — its GTM framing is synthesized from Monad's product
and go-to-market documentation, and its feature reference from the public help docs.
Product details (limits, defaults, and "not yet available" notes) reflect the
documentation at the time of writing and may change. Last updated: 2026-06-17. For
the authoritative, up-to-date version, see https://onmonad.io/help.