claude-quickstarts: the Claude app reference code Anthropic uses itself, opened up - 18 runnable projects across sessions, tools, computer use, and Managed Agents

In One Sentence

claude-quickstarts (anthropics/claude-quickstarts) is Anthropic opening up the reference code it uses to build Claude applications itself: at capture time the repo holds 18 fully runnable projects in three tiers — chat applications, desktop and browser operation, and long-running agents plus the Managed Agents ecosystem — each with its own README, dependency list, and setup instructions, runnable straight after a clone. MIT licensed, 18,645 stars and 3,190 forks at capture, TypeScript as primary language, created 2024-08-29 and still updated weekly.

The official framing is a reference implementation: meant to be read, understood, and modified into your own project rather than imported as a production SDK. The computer-use line goes further with a CAUTION block at the top of its README — the agent has full control of mouse, keyboard, and screen with no safeguards, so it must run inside a disposable macOS VM.

Data Plane

Field	Value
Repo	anthropics/claude-quickstarts (MIT, TypeScript)
Stars / Forks (capture snapshot)	18,645 / 3,190
Created / last push	2024-08-29 / 2026-10-08
Projects	18 runnable quickstarts (including 8 managed-agents subprojects)
Entry points	Root README plus a per-project README and quickstart commands
Source	X post by Ryrenz, 2026-10-17 (2111261416602681670); GitHub trunk 9ec32b9

Project Map: Three Tiers, Eighteen Projects

Chat application tier. customer-support-agent is a Claude-powered support agent with knowledge-base access; financial-data-analyst is chat-driven financial analysis with interactive chart visualization. Together they show the smallest complete shape of "Claude plus tools plus a surface".

Desktop and browser operation tier. computer-use-demo is a containerized desktop (Docker + X11) wired to the computer_toolset_20260801 shape, where each computer action is a member tool the model calls by name; computer-use-best-practices is the pedagogical native-macOS reference (next section); browser-use-demo is a complete Playwright-backed browser tool reference — navigate, inspect the DOM, extract content, fill forms; browser-toolset and computer-toolset are the minimal examples for browser_toolset_20260801 / computer_toolset_20260801 in Python and TypeScript: one Chromium tab over CDP, one desktop over VNC (raw RFB protocol, no VNC library), plus scripts that exercise the driver without a model. They show the interface; they are not production code.

Long-running agents and Managed Agents tier. autonomous-coding is a two-agent long-horizon coding harness, and managed-agents/ holds eight subprojects showing how a managed session plugs into different product shapes.

The Closest Read: computer-use-best-practices

• Explicit tool definitions. Every computer-use and browser-use tool the model sees is fully specified in computer_use/tools/ — the exact names, descriptions, and JSON schemas that go into the API call, readable as source.
• Screenshot sizing ported. computer_use/image.py ports the API's reference resize, so the model sees exactly the pixels you send and click coordinates stay accurate.
• Batch tools. computer_batch / browser_batch let the model chain confident actions in one turn; the demo appends a BATCH_REMINDER after a lone single-action call to nudge batching, which cuts latency and cost directly.
• Sandbox and trajectory. sandbox-exec-sandboxed bash/python (profile in sandbox/); trajectory recording into runs/… with a Streamlit replay viewer; a FastAPI debug panel for exercising tools by hand.
• Prompt caching and server-side compaction written into the agent loop as default patterns, paired with Anthropic's computer-use best-practices guide for side-by-side reading.

It runs against the real macOS desktop with no Docker, so the README insists on a disposable macOS VM (UTM or Parallels guests); opening the folder in Claude Code and running /first-run gives a guided walkthrough.

The Managed Agents Ecosystem: Eight Subprojects, Eight Deployment Shapes

• chat-sdk: a persistent Managed Agents session per conversation behind a Vercel Chat SDK surface; a research analyst researches with web search and streams its brief token by token while a live feed shows tool calls; swapping the adapter runs the same handler on Slack, Teams, Discord, Telegram, or WhatsApp.
• copilot-kit-ag-ui: bridges a managed session to the AG-UI protocol, streams replies with event deltas, and renders agent tool calls as generative UI components in the chat.
• daily-brief: a weekday scheduled agent reading Slack channels and GitHub pull requests and posting one brief; the deployment is defined entirely as files applied with ant apply (agent, environment, two memory stores, vault, cron deployment); a read-only preferences store sits next to a read-write state store; per-source bookmarks, a ledger against repeats, and a source that cannot be read is reported as unreadable rather than as a quiet day — designed to fail well unattended.
• knowledge-wiki: distills a document corpus once into a versioned memory-store knowledge wiki (parallel extraction sessions, a resolve pass, a steered consolidation dream), then answers repeated analyst questions from the wiki with provenance on every fact at a fraction of the per-question token cost of raw-document search; the worked example is a real M&A data room from public SEC EDGAR filings.
• linear / slack: stateless webhook bridges — a mention or assignment creates a session with the channel/thread or Linear session IDs stored in session metadata, and the session.status_idled webhook reads that metadata back to post the reply in-thread; no database, no long-lived connection.
• mcp-server-typescript: wraps the Managed Agents Sessions API as nine MCP tools — eight 1:1 with endpoints, and wait_for_idle turning the SSE event stream into a single request/response call; the same handlers over stdio and Streamable HTTP; a bearer token plus an agent allowlist bound what a caller can reach.
• roadtrip-planner: Next.js with no chat framework and no database, demonstrating four API features on one screen — token-by-token streaming with event_deltas, vault credentials injected at a specific injection_location, a per-session model override via agent_with_overrides, and a multiagent coordinator handing its draft to a reviewer agent in a session thread.
• sentry: a cron-scheduled Sentry triage agent with no host process; Sentry's Agent Plugin for guided setup; a refreshable MCP OAuth credential persisted in a vault.

autonomous-coding: A Two-Agent Long-Horizon Harness

The initializer agent (session one) reads app_spec.txt, writes a feature_list.json with 200 test cases, sets up the project structure, and initializes git; the coding agent (sessions two onward) picks up where the last session left off, implements features one by one, and marks them passing in the list. Every session runs with a fresh context window; progress persists through feature_list.json and git commits; sessions auto-continue. The security model is defense in depth: an OS-level sandbox, filesystem restrictions to the project directory, and a bash allowlist (ls/cat/head/tail/wc/grep, npm/node, git, ps/lsof/sleep/pkill limited to dev processes).

Running It and Making It Yours

Five uniform steps: clone the repo, enter the subdirectory, install dependencies, set ANTHROPIC_API_KEY, run. The MIT license permits commercial modification. Keep the boundaries in mind: it is a reference implementation, not a production SDK; the computer-use line must run in a VM; and the root README repeats the same advice as every subproject — run the official example end to end before guessing from docs.

Why It Belongs on the Harness Axis

The expensive part of going from zero to a working Claude API integration is never the features; it is knowing how the thing should be assembled: how sessions persist, how tools attach, how an agent resumes after it crashes. claude-quickstarts writes those answers into runnable code — session persistence (feature_list.json plus git, session metadata), tool attachment (explicit schemas, toolset member tools, the nine-tool MCP server), crash recovery (status_idled webhooks, ledgers, bookmarks), and sandboxing with trajectories (sandbox-exec, allowlists, runs/). That is exactly the question list of the agent-harness axis, so it is bridged to the harness capability domain with vertical development.