The system at a glance
Claude is one assistant reachable through several surfaces (places you work), powered by a family of models (the engines), extended by skills (packaged instructions), connectors (hands into your real tools), memory (what it retains about you), and scheduled tasks (work that runs on its own). The art is picking the right piece for the job — that's what this manual is for.
The pieces in one table
| Piece | Kind | One-line job | Lives / persists |
|---|---|---|---|
| Chat | Surface | Conversation; quick questions and one-off work | Chat history in your account |
| Projects | Surface | Chats grouped under standing instructions + knowledge files | Cloud, per-project |
| Cowork | Surface (mode) | Agentic multi-step work on real files and tools | Cloud sessions in your account |
| Cowork projects | Surface | Cowork tasks grouped with instructions, folders & own memory | Locally on your desktop |
| Artifacts | Output | Standalone documents/apps Claude builds; publishable at a stable link | Artifacts gallery (published) |
| Dispatch | Surface | One phone-reachable thread that routes tasks to Code or Cowork | Continuous conversation |
| Claude Code | Surface | Agentic coding from the terminal | Your repos + sessions |
| Skills | Machinery | Packaged instructions that auto-load for matching tasks | Settings → Capabilities → Skills |
| Connectors | Machinery | Claude's hands into Gmail, Drive, Slack, any MCP tool | Settings → Connectors |
| Memory | Machinery | What Claude retains about you across conversations | Settings → Memory (editable) |
| Scheduled tasks | Machinery | Cowork runs that fire on a cadence, device off | Cloud scheduler |
Which piece does the job?
| You want to… | Reach for | Why not the others |
|---|---|---|
| Ask a question, draft a thing, once | Chat | Zero setup; everything else is overhead for a one-off |
| Keep returning to one topic with standing context | Project | Chat forgets instructions between conversations; a project holds them |
| Do real multi-step work on files & tools | Cowork | Chat talks about work; Cowork does it — and keeps going with your laptop closed |
| That, recurring, with standing rules & file paths | Cowork project | Adds instructions + its own memory to Cowork tasks |
| Keep or share something Claude built | Published artifact | A chat reply scrolls away; a published artifact has a stable link and versions |
| Fire off work from your phone | Dispatch or a cloud Cowork task | See the crucial difference on the Surfaces tab — one needs your desktop awake, one doesn't |
| Do the same task the same way, every time | Skill | Instructions you'd otherwise re-paste; fires automatically when relevant |
| Have it happen on a schedule, no ask | Scheduled task | The only piece that runs without you initiating |
| Let Claude act inside your email / files / calendar | Connector | Without one, Claude can only talk about your tools, not touch them |
The model family — the engines underneath
Every surface runs on one of these. You can usually pick per conversation or per scheduled task.
| Model | Positioning | Reach for it when |
|---|---|---|
| Claude Fable 5 | Newest, highest capability; adaptive thinking always on; slowest | Long-running agent work, hardest problems |
| Claude Opus 5 | High capability for complex agentic & enterprise work | Heavy work where Fable is overkill |
| Claude Sonnet 5 | Best speed-to-intelligence balance | Everyday default |
| Claude Haiku 4.5 | Fastest, cheapest, near-frontier | Quick lookups, high-volume automation |
How to read this manual
| Surfaces tab | The comparison matrix first — then pill sub-tabs for each surface's detail, so comparing stays one glance away |
|---|---|
| Machinery tabs | Skills, Connectors, Memory, Scheduled Tasks — each with mechanics, settings locations, and watch-outs |
| Topic Index | "Where does my context live?" cross-comparison + a filterable A–Z that jumps anywhere |
| Freshness | The footer shows when sources were last checked. A monthly scheduled task re-checks Anthropic's docs and updates this page in place — same link. |
Surfaces
the places you work with Claude — and how to pick oneSame Claude, different rooms. What changes between surfaces is what context is standing by, whether work continues without you, and what Claude can touch. The matrix compares them; the pills below it drill into each one.
The comparison matrix
| Surface | Setup | Standing context | Runs without you? | Touches your stuff via | Best for |
|---|---|---|---|---|---|
| Chat | None | Memory only | No — it's a conversation | Connectors | Questions, drafts, one-offs |
| Project | Instructions + knowledge files, editable anytime | Its instructions, docs & per-project memory | No | Connectors | A recurring topic or role |
| Cowork | Pick "Cowork" in the message box | Memory + whatever you connect | Yes — cloud session keeps working, laptop closed | Connectors + local folders (desktop app open) | Multi-step work on real files |
| Cowork project | Instructions, folders, linked context; desktop-local | Its instructions + its own task memory | Yes (its cloud tasks do) | Same as Cowork | A recurring body of file work |
| Artifact | Ask for one; click Publish to keep it | — (it IS output) | — | — | Deliverables with a stable link, versions, sharing |
| Dispatch | One continuous thread, set up once | The thread itself | No — needs your desktop awake with the app open | Your actual desktop | Phone-to-desktop task routing |
| Claude Code | Terminal install | Repo + CLAUDE.md files | Cloud sessions can | Your filesystem & git directly | Software development |
KindConversation surface
SetupNone
WhereWeb · desktop · mobile
PlansAll, incl. Free
| Purpose | The default room: ask, draft, think, iterate — turn by turn |
|---|---|
| Context it sees | This conversation + your global memory + anything you attach; can search your past chats on request ("what did we decide about…") |
| Can it act? | Only through connectors (send an email, create an event) — otherwise it produces text and artifacts |
| Incognito | Incognito chats skip history and memory entirely — for anything you don't want retained |
Watch out: chat doesn't carry standing instructions between conversations — if you're re-pasting the same setup, that's a Project (context) or a Skill (procedure) asking to exist.
KindCloud workspace
SetupInstructions + knowledge files
PlansFree: up to 5 · paid: expanded
SharingTeam/Enterprise only
| Purpose | Bundle chats under standing custom instructions and a knowledge base, so a recurring topic never starts from zero |
|---|---|
| Knowledge base | Upload docs, code, files; on paid plans, RAG (Retrieval-Augmented Generation — fetching only the relevant passages) stretches capacity ~10× past the raw context limit |
| Own memory | Each project keeps a separate memory space, isolated from other projects and from non-project chats |
| Editable | Instructions and files can be changed anytime — every future chat in the project picks the change up |
Watch out: project knowledge doesn't leak out — a regular chat can't see it, and project A can't see project B · sharing needs Team/Enterprise; on Pro a project is yours alone.
KindAgentic mode
SinceCloud sessions, July 2026
WhereDesktop · web · mobile (paid plans)
RunsOn Anthropic's servers
| Purpose | Claude as a worker, not a chat partner: multi-step tasks on real files — organize, build, edit, research — delivering finished output |
|---|---|
| How it runs | Pick "Cowork" in the message box. The session runs in an isolated cloud environment: close the laptop, it keeps going; reopen from any device |
| Local files | Connect folders from your computer — readable/writable only while the desktop app is open to bridge them. Cloud-side files need no bridge. |
| Approval modes | Per-session: Manual (approve each action) · Auto (safety-checked autonomy) · Skip (no checks — earn this one) |
| Extras | Sub-agents for parallel workstreams · builds real Excel/PowerPoint/Word files · browser automation · shares memory with Chat |
Watch out: "cloud session" ≠ "can reach my desktop" — local folders, browser control, and computer use all still require the desktop app open · give Cowork outcomes, not keystrokes: "produce X meeting these criteria" beats a script of steps.
KindCowork workspace
LivesLocally on your desktop
MemoryOwn, auto-on, per-project
SharingNot shareable
| Purpose | Group recurring Cowork tasks under standing instructions, connected folders, and scheduled tasks — the "same file work, every week" home |
|---|---|
| Components | Instructions (tone, rules, naming conventions) · Context (local folders, linked chat projects, URLs) · Scheduled tasks scoped to it · Memory from past tasks, applied to future ones |
| Creating one | From scratch, from an existing folder, or by importing a chat project's instructions as the starting point |
| vs. chat Projects | Chat projects: cloud, conversation-centric. Cowork projects: desktop-local, task-centric, wrapped around real folders |
Watch out: desktop-only and not cloud-synced — the project definition lives on that one computer · its memory stays inside it; nothing carries to other projects.
KindOutput, not a place
TypesDocs · code · HTML apps · SVG · diagrams · React
PublishStable link + gallery
PlansAll; storage & AI features on paid
| Purpose | Substantial standalone content in its own window — things you'll edit, reuse, or share rather than scroll past |
|---|---|
| Versions | Every revision is kept; a version selector switches between them. Inline "Edit with Claude" works on highlighted text. |
| Publishing | Publish gives an artifact a stable URL, a place in your Artifacts gallery, and shareability — updates land at the same link (this manual is one) |
| Superpowers | Published artifacts can embed Claude itself (interactive apps that answer questions) and keep persistent storage (up to 20 MB, text) on paid plans — viewers' usage bills to their subscription, not yours |
Watch out: an unpublished artifact lives only inside its conversation — Publish is what makes it findable later · published means one Share away from public: keep sensitive content unpublished.
KindPhone-to-desktop routing
ShapeOne continuous conversation
RequiresDesktop awake, app open
| Purpose | Message Claude from your phone; it runs the task on your desktop computer — one thread reachable from either device, no restarting context |
|---|---|
| Routing | Claude sorts the task itself: development work spins up a Claude Code session, knowledge work spins up Cowork — each appears in its sidebar |
| What you see | Not the steps — the outcome: "Claude messages you the result (a spreadsheet, a memo, a pull request)," with push notifications for completion or approvals |
| The constraint | Dispatch tasks execute on your desktop machine — it must stay awake with the Claude app open while Claude works |
Dispatch vs. cloud Cowork — the decision: need Claude on your phone while away? If the task can run purely in the cloud (connectors, cloud files), start a normal Cowork task from the mobile app — it survives your desktop being off. Use Dispatch when the task genuinely needs your desktop: its local files, its browser, its apps.
KindDeveloper surface
WhereTerminal (CLI) + IDEs
ContextYour repo + CLAUDE.md
| Purpose | Agentic coding: Claude reads, edits, tests, and commits in your actual codebase from the command line |
|---|---|
| Standing context | CLAUDE.md files in the repo carry project conventions — the developer's equivalent of project instructions |
| Relation to the rest | Skills work here too; Dispatch routes dev tasks here; cloud sessions exist for it as well. For non-code work, Cowork is the better-shaped tool. |
Watch out: it's a power tool for software work — if your task is documents, files, and research rather than code, you want Cowork, not Code.
Skills
packaged instructions that load themselves when relevantA skill is a folder of instructions (plus optional scripts and resources) that Claude pulls in automatically when a task matches it. Write the procedure once; every future session that needs it gets it — across Chat, Cowork, and Claude Code.
KindReusable instructions
StandardAgent Skills (agentskills.io) — portable across platforms
WhereChat · Cowork · Code · API
ManageSettings → Capabilities → Skills
| How they trigger | Progressive disclosure: Claude scans available skills' descriptions, loads only the relevant one's full instructions when your request matches — no context wasted otherwise. The description is therefore the trigger; write it rich with the phrases you'd actually say. |
|---|---|
| Anatomy | A folder with SKILL.md at minimum: YAML frontmatter (name, description) + Markdown body of instructions. Advanced skills add scripts and reference files. |
| Four flavors | Anthropic skills (documents: Excel, Word, PowerPoint, PDF) · custom (yours — like codebook-builder) · organization-provisioned (Team/Enterprise admins push to everyone) · partner (Notion, Figma, Atlassian) |
| Power source | A skill has no abilities of its own — it steers whatever the session can already do. Acting on Gmail still needs the Gmail connector; the skill just says how. |
| Requirement | Code execution must be enabled (Settings → Capabilities) |
The lifecycle
| Stage | How | Notes |
|---|---|---|
| Get | Settings → Capabilities → Skills → Browse skills; or ask Claude to draft one as a proposal you save | Anthropic + partner skills toggle on; custom ones upload |
| Trigger | Just work — a matching request fires it; or invoke by name (/skill-name) | You'll see it load in the conversation |
| Update | Replace/edit the skill in Settings; or ask Claude to propose the revision for you to save | A skill can't rewrite itself — updating is always a human-approved step |
| Scale up | Bundle skills + connectors + agents into a plugin; distribute via marketplaces | Org owners can provision to whole teams; Enterprise can security-scan |
Watch out: a vague description means the skill silently never fires — the #1 failure mode · skills carry instructions, not credentials or powers: no connector, no action · too many overlapping skills can fight over the same request; keep triggers distinct · skills you write are also readable instructions to future Claude — keep them precise, they'll be followed literally.
Connectors
Claude's hands — via MCP, the Model Context ProtocolWithout connectors Claude can only talk about your email, files, and calendar. A connector plugs a real tool into the session — search Gmail, write to Drive, query a database — with every action gated by permissions you control.
KindTool integrations
ProtocolMCP — Model Context Protocol, an open standard
ManageSettings → Connectors
PermissionsAlways allow · Needs approval · Blocked
| How it works | Each connector is an MCP server exposing tools (actions Claude can call). You authorize it once (usually OAuth — the "sign in with Google" dance); Claude then calls tools mid-conversation, visibly |
|---|---|
| First-party set | Google Workspace (Gmail, Calendar, Drive) · Microsoft 365 · Slack · and a growing directory of partner connectors |
| Custom | Any remote MCP server can be added by URL — this is how niche tools and your own databases plug in |
| Desktop vs web | Web connectors run in the cloud and work everywhere; desktop-app connectors (local MCP servers) reach things on your machine and work only where that machine is bridged |
| Approval flow | Read actions are generally free; write actions (send, delete, move) default to asking you first — per-tool permissions tighten or loosen this |
Worked example — what Google Workspace actually allows
| Connector | Claude can read | Claude can DO | Can't |
|---|---|---|---|
| Gmail | Search, read emails & drafts, metadata | Draft · send · reply · forward (approval by default) | Read attachment contents (metadata only) |
| Calendar | Events, shared calendars, mutual availability | Create · update · delete events; manage attendees; respond to invites | — |
| Drive | Docs, Sheets, Slides, PDFs, Office files; metadata, permissions, history | Save new files · upload · create folders · share · move · trash · update (approval by default) | Process images embedded in documents (text only) |
Stale-fact alert: "Claude can't delete or edit Drive files, only create new ones" was once true — the current connector can update files in place, move them, and send them to trash. Capabilities on this tab are exactly the kind of thing the monthly refresh re-checks.
Permissions discipline
| Setting | Meaning | Use for |
|---|---|---|
| Always allow | Claude uses the tool without asking | Read-only tools you trust: search, list, fetch |
| Needs approval | Every call pauses for your yes | Anything that sends, changes, or deletes — the sane default |
| Blocked | Tool is off entirely | Capabilities you never want exercised from a given context |
Watch out: a connector grants its FULL tool list — read the list before authorizing, not after · content fetched through connectors (emails, docs, web pages) is data, and Claude should treat instructions found inside it with suspicion; be deliberate about pairing "Always allow" writes with tools that ingest untrusted content · connectors authorize per-account: your Gmail connector is yours, not your org's.
Memory
what Claude retains about you — and exactly where it appliesMemory is Claude keeping notes as you work — your role, projects, preferences, decisions — so conversations stop starting from zero. The part people miss: memory is scoped. Knowing which pool a conversation draws from explains almost every "why doesn't it remember that?"
KindPersistent context
ManageSettings → Memory — view, edit, delete by topic
DefaultOn for Free/Pro/Max · admin-enabled for Team/Enterprise
Mechanics
| What gets stored | Work context: role, projects, preferences, decisions, style — captured live as you converse, filed as categorized Topics (since Aug 2026) |
|---|---|
| Control | Settings → Memory lists every topic — read, edit, or delete each; changes apply to all future conversations. Or just tell Claude: "remember X", "forget Y" |
| Pause vs reset | Pause stops new memories, keeps existing · Reset deletes permanently |
| Sensitive topics | Health, race, religion, politics, gender identity are excluded by default; a Settings toggle opts in. Some things are never stored regardless: government IDs, financial account numbers, criminal history. Claude tells you when it declines to save. |
| Chat search | Separate from memory: on paid plans Claude can search your past conversations on demand — "what did we discuss about the loft tank?" — projects and non-project chats searched separately |
Watch out: memory is a distillation, not a transcript — for exact wording, use chat search or the original conversation · project facts stay in the project pool: tell Claude a thing inside Project A and a plain chat won't know it · memory ≠ project knowledge files: files are documents you curate, memory is notes Claude takes.
Scheduled Tasks
work that happens without you askingA scheduled task is a Cowork run on a timer: the prompt you wrote fires on a cadence, in the cloud, with your connectors and skills available — whether your computer is on or not. It's the piece that turns Claude from a tool you use into staff you've briefed.
KindAutomation
RunsIn the cloud — device can be off
CadenceHourly · daily · weekdays · weekly · manual
PlansAll paid; web/mobile in beta
Mechanics
| Creating | Create with Claude (it interviews you, then generates the task) or set up manually: name, prompt, approval mode, frequency, optional model, folders |
|---|---|
| Each run | Is its own fresh Cowork session — write the prompt as a complete standalone briefing: goals, sources, exact links, where output goes |
| Capabilities | Same as any Cowork task: connectors, skills, plugins — Slack searches, web research, file generation, report delivery |
| Managing | View all tasks with past/upcoming runs · edit prompt or cadence · pause/resume · delete · run on demand |
| The limit | Cloud runs can't touch folders on your computer — cloud files and connectors only. Anything local needs you (or Dispatch) present. |
Patterns worth stealing
| Pattern | Cadence | The prompt's job |
|---|---|---|
| Morning brief | Weekdays, early | Pull calendar + inbox + task list via connectors; deliver one compact plan |
| Weekly report | Fridays | Gather the week's activity from named sources; produce the same document shape every time |
| Monitor & alert | Hourly/daily | Check a source for a condition; stay silent unless it's met |
| Living-document refresh | Monthly | Re-check primary sources, diff against a published artifact, republish to the same link — this manual maintains itself this way |
Watch out: runs don't remember previous runs — a prompt that says "continue from last time" fails; give it durable locations (an artifact URL, a Drive file) to read its own past state from · schedule against real needs, not anxiety: an hourly check nobody reads is pure cost · always include "if nothing noteworthy, say so briefly" or your phone fills with noise.
Topic index
The cross-cutting question first — where does my context live? — then a filterable A–Z that jumps to any section.
Where does context live? — one concept, four rooms
| Context kind | Chat | Project | Cowork | Cowork project |
|---|---|---|---|---|
| Standing instructions | — (re-state each time, or use a skill) | Project instructions, editable anytime | — (per-task prompt) | Project instructions + conventions |
| Files & knowledge | Attachments, this chat only | Knowledge base (RAG-stretched on paid) | Connected folders + cloud files | Its folders + linked context |
| Memory | Global pool | Its own isolated pool | Global pool (cloud sessions) | Its own isolated pool |
| Survives laptop closed? | The chat waits for you | Same | Yes — session keeps working | Its cloud tasks do |
| Output that persists | Artifacts (publish to keep) | Artifacts + project docs | Real files, delivered & saved | Files in its folders |
A–Z index
- A
- Always allow / Needs approval / BlockedConnectors
- Approval modes (Manual / Auto / Skip)Cowork
- Artifacts — versions, publishing, gallerySurfaces
- C
- Chat — what it sees, incognitoSurfaces
- Chat search (find past conversations)Memory
- Claude CodeSurfaces
- Comparison matrix — all surfacesSurfaces
- Connectors — how MCP worksConnectors
- Cowork — cloud sessionsSurfaces
- Cowork projectsSurfaces
- D
- Desktop app as the local bridgeSurfaces
- Dispatch — phone to desktopSurfaces
- Drive / Gmail / Calendar — exact abilitiesConnectors
- I
- Incognito chatsSurfaces
- K
- Knowledge base & RAGProjects
- M
- MCP — Model Context ProtocolConnectors
- Memory — scopes, editing, pausingMemory
- Models — Fable, Opus, Sonnet, HaikuOverview
- P
- Permissions disciplineConnectors
- Plugins & marketplacesSkills
- Projects — instructions & knowledgeSurfaces
- Publishing an artifact (stable link)Surfaces
- R
- Refresh pattern (this manual's upkeep)Tasks
- S
- Scheduled tasks — mechanicsTasks
- Scheduled task patternsTasks
- Sensitive topics & never-stored dataMemory
- Skills — how they triggerSkills
- Skills — get, update, provisionSkills
- SKILL.md anatomySkills
- W
- Which piece does the job?Overview
- Where does context live?Index