Anthropic · Claude Desktop

One app. Chat, Cowork, and Claude Code.

Claude Desktop is Anthropic's native app for macOS and Windows. It's the umbrella surface: same Claude models as claude.ai, a local MCP client, plus first-class access to Claude Cowork (collaborative sessions) and Claude Code (the coding agent with its full feature set — slash, hooks, skills, subagents, memory).

macOS 11+ Windows 10/11 Free / Pro / Max / Team MCP client built-in Claude Cowork Claude Code (full feature set) No Linux build

What Desktop covers

Desktop is the umbrella surface for Anthropic's consumer + pro products. One app, one sign-in, one plan — and everything below is inside it:

Chat + Artifacts

Core conversation surface. Side-panel workspace for code, docs, SVGs, React components. Iterate, download, share.

Projects

Scoped workspace with its own knowledge base (up to 200k tokens) and custom instructions. Pro+.

Claude Cowork

Collaborative sessions — multiple humans + Claude sharing artifacts, files, and tool state in one live room.

Claude Code

Full coding agent — slash commands, hooks, skills, subagents, MCP, permissions, memory, Agent SDK. Not a stripped-down variant.

MCP

Connect to Filesystem, GitHub, Slack, Postgres, anything with an MCP server — stdio, HTTP, or OAuth.

Built-in tools

Web search, Analysis tool (Python sandbox), image understanding, PDF parsing — no config needed.

Umbrella surface, precisely Desktop is not just the chat window. It's the single signed-in client that exposes Anthropic's consumer chat (claude.ai), its collaborative mode (Cowork), and its coding agent (Claude Code) with every one of that agent's features. The terminal claude CLI still exists and is still canonical for repo-local work — Desktop just means you don't have to leave the GUI to use it.

Architecture

// claude desktop · runtime

     ┌──────────────────────────────────────────┐
     │         Claude Desktop (Electron)        │
     │ chat · artifacts · projects · cowork · code │
     └─────────────┬────────────────────────────┘
                   │
         ┌─────────┴──────────┐
         │                    │
  ┌──────┴──────┐      ┌──────┴──────┐
  │  Anthropic  │      │ MCP client  │
  │     API     │      │   (local)   │
  └─────────────┘      └──────┬──────┘
                               │
                claude_desktop_config.json
                               │
         ┌─────────────────────┼─────────────────┐
         │                     │                 │
  ┌──────┴──────┐     ┌────────┴───────┐  ┌──────┴──────┐
  │ Filesystem  │     │    GitHub      │  │   Postgres  │
  │ MCP (stdio) │     │  MCP (stdio)   │  │ MCP (stdio) │
  └─────────────┘     └────────────────┘  └─────────────┘

     local processes Desktop spawns · stdout/stdin JSON-RPC

Who it's for

General knowledge work — writing, summarizing, research, data exploration.
Operators with MCP servers connecting real systems they want to poke at conversationally.
Teams on Projects — scoped knowledge + shared instructions beat one-off chats.
Developers who want Claude next to their work but not in their work — use Claude Code for that.

Install

Download, sign in, open Developer Mode.

Desktop ships as a signed installer. No CLI, no build step. The install is done in a minute; wiring MCP takes a config edit and a restart.

Download

Get the installer from claude.ai/download. Anthropic serves a .dmg for macOS and a .exe for Windows. There is no official Linux build (as of 2026-04) — Linux users run claude.ai in a browser.

macOS

# double-click the .dmg, drag Claude.app to Applications open ~/Downloads/Claude.dmg # first launch — sign in with the same account you use on claude.ai open -a Claude

Windows

# Claude-Setup.exe is a per-user installer — no admin needed .\Claude-Setup.exe

Sign in

Same credentials as claude.ai. Your plan (Free / Pro / Max / Team / Enterprise) carries over — Projects, larger context, and higher rate limits come from the plan, not the app.

Developer Mode

Enable Developer Mode before editing MCP config. It surfaces config paths and gives you access to the MCP log viewer.

macOS: ⌘ + , → Developer → toggle on
Windows: Ctrl + , → Developer → toggle on

Config file locations

Platform	Path
macOS	~/Library/Application Support/Claude/claude_desktop_config.json
Windows	%APPDATA%\Claude\claude_desktop_config.json
MCP logs (macOS)	~/Library/Logs/Claude/
MCP logs (Windows)	%APPDATA%\Claude\logs\

Gotchas

Config file won't exist on a fresh install — create it yourself the first time you add an MCP server.
Changes to claude_desktop_config.json require a full app restart, not just a new conversation.
On Windows, the path uses backslashes in JSON — double them: "C:\\\\Users\\\\you\\\\...".

Artifacts

A side-panel workspace that survives the conversation.

Artifacts split substantial outputs out of the chat stream so you can iterate, download, and share them. Trigger them for anything more than ~15 lines that you'll want to reuse.

What qualifies as an artifact

Code — scripts, components, full files in any language.
Documents — markdown, long-form writing, structured reports.
React components — rendered live in the panel with state and Tailwind.
SVG / Mermaid — diagrams rendered inline.
HTML — single-file pages, rendered in a sandboxed iframe.

Iterating

Ask for changes in chat — Claude edits the existing artifact in place rather than producing a new one. Version history lives in the panel; you can scrub back. Keep requests focused: "change the button color to terracotta" beats "redo the whole header."

Artifact, precisely A named, versioned output that lives next to the conversation. Editable by follow-up prompts, downloadable as a file, shareable as a public URL. Not sandboxed from you — sandboxed for you: the React/HTML preview runs in an isolated iframe so nothing leaks into your desktop.

Sharing and download

Download — saves the current version to disk with the right extension.
Publish — mints a public URL (claude.ai/public/artifacts/...) for code, docs, and React components. Anyone with the link can view; changes you make later update the live page.
Remix — any signed-in user can fork a published artifact into their own conversation.

When not to use artifacts

Short snippets (≤15 lines) — they clutter the panel for no gain.
Things you only need once — a one-off shell command, a quick answer.
Conversational content — explanations, summaries, discussion.

Projects

A workspace with its own knowledge and instructions.

Projects are scoped containers for related conversations. Each one has a knowledge base (up to ~200k tokens of your files) and custom instructions that prepend every chat. Pro and above.

Anatomy

Knowledge — files you upload (PDF, code, docs, CSV). Claude pulls from these automatically in every conversation in the project.
Custom instructions — a system-prompt-ish block that defines tone, format, constraints. Applied on top of Claude's base behavior.
Conversations — threads inside the project. They inherit the knowledge + instructions; they don't share memory with each other.

When to spin up a project

You're doing the same kind of work repeatedly — client reports, code reviews of one repo, editing the same book.
You have a stable reference set — a style guide, an API spec, a corpus — that should be in scope every time.
You're working with a team (Team/Enterprise plan) and want everyone hitting the same knowledge.

Team sharing

On Team and Enterprise plans, a project can be shared with the workspace. Members see the same knowledge and instructions, but conversations stay private unless explicitly shared. Good for playbooks; bad if you care about who-edited-what audit trails (there aren't any).

Projects are not RAG

Small/medium knowledge bases are loaded into context, not embedded and retrieved. Once you exceed the window, older files stop appearing.
No cross-project memory. Conversations in Project A can't see files in Project B.
Don't upload secrets — there's no per-file ACL, and anyone with project access sees everything.

Claude Cowork

Live sessions where humans and Claude share one workspace.

Cowork is Anthropic's collaborative mode — surfaced natively in Desktop. Multiple participants, one shared session, live artifacts and tool state everyone can see and edit.

What a Cowork session is

A single shared workspace that multiple humans join alongside Claude. Everyone sees the same conversation, the same artifacts, the same MCP tool results. Turns interleave — a teammate can add a message while Claude is mid-response, and Claude picks it up on the next turn.

How to start one

From an existing conversation: Share → Start Cowork.
From a Project: new Cowork session inherits the project's knowledge + instructions.
From scratch: ⌘+⇧+N → Cowork.

Invites and roles

Role	Can do
Owner	Everything — kick, delete, change permissions, close session
Editor	Send messages, add files, approve tool calls, edit artifacts
Viewer	Read-only — see the session, copy out, no writes

Session state

Artifacts are shared — edits propagate to every participant in real time.
Files + uploads are shared — everyone's attachments are in-context for the whole room.
MCP tool approvals are per-owner — the session owner decides what Claude can call; editors can request but not approve.
Sessions persist — leave and rejoin via Desktop, the state is still there.

Cowork vs Projects

They're orthogonal and compose. A Project is your scoped knowledge base and instructions, with private threads. A Cowork session is a shared live room. Run a Cowork session inside a Project and it inherits the knowledge — common pattern for team playbooks where everyone hits the same reference material.

Worth knowing

Cowork is plan-gated — Free gets limited participants, Pro more, Team/Enterprise the most plus admin controls.
There's no merge-conflict story for artifacts — last edit wins. For contested edits, split into multiple artifacts.
Viewers can still screenshot. Don't paste secrets expecting role-gating to protect them.

Claude Code · in Desktop

The full coding agent, driven from the desktop app.

Desktop exposes Claude Code with every feature the terminal CLI has — slash commands, hooks, skills, subagents, MCP, permissions, memory, Agent SDK. Same ~/.claude, same CLAUDE.md loading, same model picker. Not a lite version.

What you get

Slash commands

Built-in (/help, /clear, /model) and custom commands from .claude/commands/.

Hooks

PreToolUse, PostToolUse, UserPromptSubmit, Stop, SubagentStop — all fire the same as in terminal.

Skills

.claude/skills/*/SKILL.md files are auto-discovered and invokable.

Subagents

general-purpose, Explore, Plan, plus any custom agent types you've defined.

MCP

Same claude_desktop_config.json servers are available to Code sessions.

Permissions

Ask / accept-edits / bypass — prompts surface in the Desktop UI, not a terminal.

Memory

CLAUDE.md at repo root, ~/.claude/CLAUDE.md, and project-scoped memory all load as usual.

Agent SDK

Build on the same SDK the CLI uses — custom agents, tools, and workflows.

Launching a Code session

# from Desktop, open Claude Code on a working directory File → New Claude Code Session → pick folder # or via the app menu Claude Code → Open in… → /path/to/repo # the terminal CLI still works in parallel — same ~/.claude state cd ~/repo && claude

Desktop UI vs terminal UI

Thing	Desktop	Terminal
Diffs	Side-by-side viewer	Inline text diff
Permission prompt	Modal dialog	TUI picker
File tree	Persistent sidebar	On-demand
Hooks output	Log panel	Stdout interleaved
Copy / paste	Native	Terminal-dependent
Session state	`~/.claude/projects/`	`~/.claude/projects/`

When Desktop Code makes sense

You're in a long debugging session and want diffs in a proper GUI, not a terminal.
You're pairing with a teammate in a Cowork session and want the coding agent in the same room.
You want to hand a task off from chat into Code without context-switching to iTerm.

When to stay in the terminal CLI

Headless / scripted agent runs (claude -p "…") — Desktop doesn't do headless well.
SSH / remote workflows where GUI isn't available.
Tmux-heavy workflows where Claude Code is one pane among many.

For everything else, it's a preference call — the agent is the same.

One plan, one auth Signing into Desktop signs you into the Code sessions inside it. Rate limits and model access apply across chat, Cowork, and Code — they draw from the same plan quota. No separate Claude Code subscription, no separate API key required.

Deep-dive references

Model Context Protocol

Wire Desktop to your systems with one JSON file.

MCP lets Claude Desktop talk to local processes that expose tools, resources, and prompts. The desktop app is the client; you run servers. Edit claude_desktop_config.json, restart, done.

Minimal config

// ~/Library/Application Support/Claude/claude_desktop_config.json { "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents", "/Users/you/Desktop" ] }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." } } } }

Transport types

Transport	How it runs	Use for
stdio	Desktop spawns a subprocess, talks over stdin/stdout	Local tools (filesystem, git, docker)
HTTP	Desktop connects to a running HTTP server	Team services, hosted MCP
OAuth 2.1	HTTP + OAuth flow in the app	SaaS integrations (Linear, Asana, etc.)

Approving tool calls

By default, every MCP tool call requires your approval. You'll see "Allow for this chat" / "Allow always" / "Deny." Approvals are per-server, per-tool. For trusted local-only servers (filesystem you own), "Allow always" is fine. For anything that touches production or costs money, keep it on per-chat.

Debugging

# tail MCP logs live (macOS) tail -f ~/Library/Logs/Claude/mcp*.log # inspect a server outside Desktop with the MCP Inspector npx @modelcontextprotocol/inspector \ npx -y @modelcontextprotocol/server-filesystem /tmp

MCP troubleshooting

Server won't start → check the log, almost always a missing env var or wrong path.
command not found: npx → Desktop uses a minimal PATH. Use the absolute path to node (/opt/homebrew/bin/npx) or wrap in a shell.
Changes to config don't apply → fully quit (⌘Q), not just close the window.

Built-in tools

Web search, Python sandbox, vision, PDF — no setup.

Desktop ships with a handful of tools Anthropic runs on your behalf. No config, no MCP — toggle them on in settings and Claude uses them when the task calls for it.

Web search

Claude runs a search, reads the results, and cites the sources. Good for fresh facts, bad for deep research (it won't paginate through 30 results). Toggle in Settings → Profile → Features.

Analysis tool (Python sandbox)

A JavaScript/Pyodide sandbox where Claude writes and runs code on uploaded files. Parse a CSV, run some stats, generate a chart, return results inline. Isolated from your machine — code cannot read your filesystem or hit the network.

Works with CSV, JSON, XLSX, plain text.
Pandas, numpy, matplotlib available.
No outbound network, no persistence between messages.

Image understanding

Drop images into chat (JPG, PNG, WebP, GIF, up to 5 per message, up to 30MB each, up to ~8000×8000). Claude reads charts, transcribes handwriting, OCRs screenshots, describes photos. Multimodal is on the core model, not an opt-in tool.

PDF

Upload PDFs up to 32MB / 100 pages. Claude reads text and renders pages as images for layout-heavy documents — tables, forms, scanned pages all work. For huge PDFs, extract the relevant pages first; full 300-page docs will crowd out your context.

Extended thinking

On supported models (Opus 4.x, Sonnet 4.x), toggle Extended Thinking to let Claude spend more compute before answering. Good for: hard math, multi-step planning, tricky refactors. Bad for: anything quick — it makes responses noticeably slower.

File uploads

Drag, drop, paste. It goes into context.

Desktop accepts files directly in the compose box — drag from Finder, paste from clipboard, click the attach button. The file is read into the conversation's context, not stored long-term.

What's supported

Type	Formats	Limit
Documents	PDF, DOCX, TXT, MD, RTF	32MB / 100 pages (PDF)
Spreadsheets	XLSX, CSV	30MB
Images	JPG, PNG, WebP, GIF, non-animated	30MB, 5/message
Code	Any text-based source file	30MB

Conversation context vs Project knowledge

Drop in chat — available in this conversation only. Cleared when you start a new chat.
Add to Project knowledge — available in every conversation in that project, persisted until you remove it.

Quietly true

Files don't leave your account — they aren't used for training on Pro/Team/Enterprise plans.
The attached file counts toward your context window. A 90-page PDF can eat most of a Sonnet conversation.
Binary formats you might expect (PPTX, Keynote, Pages) aren't natively parsed — export to PDF first.

Settings

Profile, model, features, shortcuts.

Settings live behind ⌘+, (Ctrl+, on Windows). Most knobs are account-wide; a few are per-device.

Panels

Profile

Display name, personalization ("traits"), response preferences. Sets a weak system prompt applied globally.

Appearance

Dark/light/system, font size, UI density. Per-device.

Features

Toggle Web search, Analysis tool, Extended thinking, Artifacts. Off = Claude won't reach for them.

Developer

Surface MCP config path, log viewer, allow local MCP servers. Off by default.

Connectors

OAuth MCP connectors (Linear, Asana, Google Drive, etc.). Auth flow runs in-app.

Account

Plan, billing, data controls, sign out. Links out to claude.ai for the deeper knobs.

Model selection

Per-conversation dropdown in the compose bar. Default is the most capable model on your plan. Switching mid-chat is allowed — the new model sees the full conversation history.

Keyboard shortcuts (macOS)

Shortcut	Action
`⌘` `N`	New chat
`⌘` `K`	Search conversations
`⌘` `,`	Settings
`⌘` `B`	Toggle sidebar
`⌘` `/`	Show shortcuts
`⌘` `⇧` `O`	Quick capture (global)

Data controls

On Free plans, Anthropic may use your chats to train models unless you opt out. Pro, Team, and Enterprise are opt-out by default. Check Settings → Privacy on claude.ai to confirm.

vs Claude Code / Codex

Three surfaces, one model family, different jobs.

Anthropic ships Claude behind three surfaces that look similar but aren't substitutes. Pick by what you're doing, not by brand loyalty.

At a glance

	Claude Desktop	Claude Code	Codex CLI
Surface	Native chat app	Terminal / IDE	Terminal / ChatGPT
Vendor	Anthropic	Anthropic	OpenAI
Model	Claude (picker)	Claude (picker)	GPT-5 / o-series
Edits files	Yes (via Claude Code)	Yes	Yes
Runs shell	Yes (via Claude Code) / MCP	Yes	Yes
Cowork (collab)	Yes	No	No
Artifacts	Yes	No	No
Projects	Yes	No (CLAUDE.md)	No (AGENTS.md)
MCP	Client	Client	Client
Billing	Subscription	Subscription or API	Subscription or API

Pick Desktop when

You're writing, researching, analyzing, or talking through a problem.
You want Artifacts you can share publicly or hand to a non-technical teammate.
You want Cowork — live collaborative sessions with teammates + Claude.
You need a Project scope — stable knowledge + instructions across many conversations.
You want the option to launch Claude Code from a GUI without leaving the app.

Pick the Claude Code CLI when

You're running headless / scripted agent jobs.
You live in the terminal — tmux, SSH, remote hosts — and want Claude Code as one pane among many.
You want IDE integration rather than the Desktop window.
Note: the coding agent itself is the same whether launched from Desktop or the CLI.

Pick Codex when

You want the OpenAI model family for coding work, or you're already paying for ChatGPT.
You need the ChatGPT Cloud sandbox for PR-style long-horizon tasks.
Your team's infra is on OpenAI — same auth, same billing, one vendor.

The honest take Desktop collapsed the Anthropic side of the decision: chat, Cowork, and Claude Code all ship in one app now. The live choice is Anthropic stack (Desktop + Code) vs OpenAI stack (Codex) — or both, if your team straddles vendors. Running Claude Code from Desktop and the claude CLI on the same repo still works; they share ~/.claude.

One app. Chat, Cowork, and Claude Code.

What Desktop covers

Chat + Artifacts

Projects

Claude Cowork

Claude Code

MCP

Built-in tools

Architecture

Who it's for

Download, sign in, open Developer Mode.

Download

macOS

Windows

Sign in

Developer Mode

Config file locations

A side-panel workspace that survives the conversation.

What qualifies as an artifact

Iterating

Sharing and download

When not to use artifacts

A workspace with its own knowledge and instructions.

Anatomy

When to spin up a project

Team sharing

Live sessions where humans and Claude share one workspace.

What a Cowork session is

How to start one

Invites and roles

Session state

Cowork vs Projects

The full coding agent, driven from the desktop app.

What you get

Slash commands

Hooks

Skills

Subagents

MCP

Permissions

Memory

Agent SDK

Launching a Code session

Desktop UI vs terminal UI

When Desktop Code makes sense

When to stay in the terminal CLI

Deep-dive references

Wire Desktop to your systems with one JSON file.

Minimal config

Transport types

Approving tool calls

Debugging

Web search, Python sandbox, vision, PDF — no setup.

Web search

Analysis tool (Python sandbox)

Image understanding

PDF

Extended thinking

Drag, drop, paste. It goes into context.

What's supported

Conversation context vs Project knowledge

Profile, model, features, shortcuts.

Panels

Profile

Appearance

Features

Developer

Connectors

Account

Model selection

Keyboard shortcuts (macOS)

Data controls

Three surfaces, one model family, different jobs.

At a glance

Pick Desktop when

Pick the Claude Code CLI when

Pick Codex when

Companion guides