The Complete Map of Anthropic's Developer Ecosystem: 24 Repos, One Vision
A deep dive into the Claude-related public repositories in the Anthropic GitHub org — how Claude Code, Agent SDKs, MCP, plugins, GitHub Actions, and learning resources all connect into one coherent developer platform.
Updated October 21, 2026: Re-derived the whole map from the GitHub API.
coursesis archived,financial-services-pluginsis nowfinancial-services,anthropic-clihas shipped asant,claude-code-base-actionis a mirror, and the GitHub MCP server is GitHub’s repo, not Anthropic’s. Plugin and quickstart counts, the Agent SDK snippet, and the model IDs are current as of today.
If you visit github.com/anthropics, you’ll find over 110 repositories. Most developers only know about one or two. But beneath the surface, there’s a carefully designed ecosystem where every piece connects to every other piece.
I spent time mapping every Claude-related repository in the Anthropic org. Here’s what I found: 24 repos that form 7 layers of a complete developer platform — from low-level API access to fully autonomous agents, from local CLI tools to CI/CD automation, from learning resources to production monitoring.
(The count is the live, Anthropic-owned, non-archived, non-fork repos named in this article. The org also holds dozens of upstream forks like tokio and rclone, research-paper repos, and archived material — those aren’t part of the developer platform.)
This article is the map I wish I had when I started.
The Architecture at a Glance
┌─────────────────────────────────────────────────────────┐
│ Layer 7: Learning & Onboarding │
│ cookbooks → quickstarts → prompt tutorial → │
│ devcontainer-features │
├─────────────────────────────────────────────────────────┤
│ Layer 6: Monitoring & Security │
│ monitoring-guide, security-review, sandbox-runtime │
├─────────────────────────────────────────────────────────┤
│ Layer 5: CI/CD Automation │
│ claude-code-action, base-action │
├─────────────────────────────────────────────────────────┤
│ Layer 4: Plugins, Skills & Domain Extensions │
│ plugins-official, plugins-community, skills, │
│ knowledge-work, financial-services, claude-for-legal │
├─────────────────────────────────────────────────────────┤
│ Layer 3: MCP (Model Context Protocol) │
│ claude-ai-mcp (+ GitHub's github-mcp-server) │
├─────────────────────────────────────────────────────────┤
│ Layer 2: Agent SDKs (High-level) │
│ agent-sdk-python, agent-sdk-typescript, demos │
├─────────────────────────────────────────────────────────┤
│ Layer 1: Foundation │
│ anthropic-sdk-python/ts, claude-code, constitution, │
│ anthropic-cli (ant) │
└─────────────────────────────────────────────────────────┘Let’s go layer by layer.
Layer 1: The Foundation
anthropic-sdk-python & anthropic-sdk-typescript
Everything starts here. These are the official REST API SDKs — the lowest-level way to talk to Claude.
from anthropic import Anthropic
client = Anthropic()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}]
)What they provide: Messages API, streaming, tool use, message batches, token counting, file uploads, and support for AWS Bedrock and Google Cloud’s Agent Platform.
When to use: You’re building a product that calls Claude as a service — chatbots, classifiers, content pipelines, RAG systems.
Python and TypeScript are the two the rest of this map builds on, but the org also publishes official SDKs for Go, Java, Ruby, C#, and PHP.
claude-code
The flagship product. Claude Code is an agentic coding assistant that lives in your terminal. It doesn’t just answer questions — it reads your files, writes code, runs tests, manages git, and executes multi-step workflows.
Claude Code is also the runtime engine underneath the Agent SDKs. When you install the Agent SDK, it bundles Claude Code’s CLI. This is a crucial architectural decision: the SDKs don’t re-implement file operations and tool execution — they delegate to Claude Code.
Its documentation now lives at code.claude.com/docs — the old docs.anthropic.com/claude-code paths are legacy.
claude-constitution
Released January 2026 under CC0 (public domain), the Constitution defines Claude’s values, decision-making framework, and behavioral boundaries. It’s not code — it’s the ethical operating system that every Claude model runs on.
Why it matters for developers: understanding the Constitution helps you predict how Claude will behave in edge cases. It explains why Claude sometimes refuses, how it weighs competing priorities, and what its “hard constraints” are.
anthropic-cli
No longer a work in progress. This repo now ships ant, the official CLI for the Claude Platform — send messages, manage agents and sessions, upload files, and script against the API from your terminal. It’s a complement to Claude Code, not a replacement: ant is for API operations, claude is for agentic coding.
brew install anthropics/tap/antIt’s also installable with go install github.com/anthropics/anthropic-cli/cmd/ant@latest, and documented at platform.claude.com/docs/en/api/sdks/cli.
Layer 2: Agent SDKs
claude-agent-sdk-python & claude-agent-sdk-typescript
Here’s where it gets interesting. The API SDKs let you call Claude. The Agent SDKs let you build with Claude Code’s full capabilities programmatically.
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
async def main():
options = ClaudeAgentOptions(max_turns=10)
async for message in query(
prompt="Refactor the auth module to use JWT",
options=options,
):
print(message)
asyncio.run(main())Note that options takes a ClaudeAgentOptions object, not a plain dict.
Key difference from API SDKs:
| Aspect | API SDK | Agent SDK |
|---|---|---|
| Abstraction | REST API wrapper | Agent framework |
| File access | No | Full filesystem |
| Tool execution | Manual tool_use handling | Built-in (Bash, Read, Write, Edit) |
| Multi-step | You orchestrate | Agent plans and executes |
| Use case | API integration | Autonomous agents |
The Agent SDK exposes three core APIs:
query()— Fire-and-forget: give it a task, get back resultsClaudeSDKClient— Stateful, bidirectional conversationscreate_sdk_mcp_server()— Define custom tools as Python/TS functions that Claude can call
claude-agent-sdk-demos
Eight reference implementations you can read end to end:
- Email Agent (TS + React) — Full IMAP assistant with AI search and custom actions
- Research Agent (Python) — Multi-agent coordinator with parallel researcher subagents
- Excel Demo (Electron) — Desktop spreadsheet manipulation
- Resume Generator — DOCX file generation
- Simple Chat App — Minimal getting-started UI
- Ask-User-Question Previews — Patterns for asking the user mid-task
- Hello World and Hello World v2 — The simplest possible agents
These aren’t toy examples. The Email Agent has SQLite integration, WebSocket communication, and UI state management. The Research Agent demonstrates the orchestrator-worker pattern that scales to real applications.
A companion agent-sdk-workshop repo holds hands-on workshop material for building production agents on the SDK.
Layer 3: MCP (Model Context Protocol)
MCP is how Claude reaches out to the world. If the SDK is Claude’s brain, MCP is its hands.
claude-ai-mcp
The issue tracker and communication hub for MCP integration in Claude. If you’re building MCP servers and hit authentication issues, OAuth problems, or session management bugs, this is where you report them — and where protocol changes and deprecations are announced.
github-mcp-server (GitHub’s, not Anthropic’s)
Worth a correction if you’ve seen this listed as an Anthropic repo: the official GitHub MCP server lives at github/github-mcp-server. The copy in the Anthropic org is an unmaintained fork that hasn’t been updated since December 2025 — install from the upstream repo.
Written in Go, it provides tools across repos (read files, branches, commits, search code), issues, pull requests, users, code security, and experimental features.
Anthropic’s own first-party GitHub automation is the github plugin in the official plugin marketplace, plus claude-code-action in Layer 5.
Layer 4: Plugins, Skills & Domain Extensions
This layer is where the ecosystem becomes truly extensible.
claude-plugins-official
The curated marketplace, and by far the largest catalog in the ecosystem: its marketplace.json now lists 315 plugins, of which 53 are maintained in the repo itself and the rest are pulled from partner and third-party sources. Claude Code adds this marketplace for you the first time you start an interactive terminal session.
Each plugin follows a standard structure:
my-plugin/
├── .claude-plugin/plugin.json ← Metadata
├── .mcp.json ← MCP server configs
├── /commands/ ← Slash commands
├── /skills/ ← Domain knowledge
├── /agents/ ← Specialized sub-agents
└── /hooks/ ← Event automationNotable Anthropic-maintained plugins:
- code-review — Multi-agent PR review with confidence-based scoring to filter false positives
- feature-dev — 7-phase feature development workflow
- security-guidance — Pattern-based warnings on edits plus an agentic commit reviewer
- pr-review-toolkit — 6 specialized reviewer agents
- plugin-dev and skill-creator — Build and measure your own plugins and skills
The marketplace is named claude-plugins-official, so you install from it with /plugin install code-review@claude-plugins-official, or browse the Discover tab of /plugin in a session.
claude-plugins-community
The community marketplace, a read-only mirror of plugins their authors submitted to Anthropic. Add it with /plugin marketplace add anthropics/claude-plugins-community, then install with the @claude-community suffix — note the marketplace name differs from the repo name.
skills
The Agent Skills specification and reference implementations. Skills are the simplest extension unit — just a markdown file with YAML frontmatter:
---
name: pdf-expert
description: Create, manipulate, and extract from PDFs
---
# Instructions for handling PDF files...No code. No build steps. No infrastructure. Skills work across Claude Code, Claude, and the Claude API. The repo now holds 19 skills spanning creative work, development, enterprise communication, and the document skills (docx, pdf, pptx, xlsx) that power Claude’s own file creation — plus the spec in spec/ and a starter in template/.
It doubles as a plugin marketplace: /plugin marketplace add anthropics/skills, then install document-skills or example-skills.
knowledge-work-plugins
Role-based plugins that turn Claude into a domain expert. The marketplace now lists 123 plugins: 17 are Anthropic-built plugin directories in the repo itself, and 106 are partner plugins (5 of them vendored under partner-built/, the rest pulled from their authors’ own repositories).
The Anthropic-built set covers productivity, sales, customer support, product management, marketing, legal, finance, data, engineering, design, human resources, operations, enterprise search, bio-research, small business, a PDF viewer, and the meta-plugin for creating and customizing plugins.
Each connects to real tools via MCP — Slack, Notion, Jira, HubSpot, Snowflake, and dozens more. For the full breakdown, see the complete guide to the Knowledge Work Plugins.
financial-services
Formerly financial-services-plugins. Enterprise-grade financial analysis: investment banking, equity research, private equity, fund administration, and wealth management. The repo holds 64 distinct skills and 50 slash commands, packaged as 10 named workflow agents (Pitch Agent, Market Researcher, GL Reconciler, KYC Screener, and more), 6 vertical plugins, and 2 partner-built plugins from LSEG and S&P Global.
The structural change is the interesting part: everything ships two ways from one source — as a plugin you install in Claude, or as a Claude Managed Agent template you deploy behind your own workflow engine. Same system prompt, same skills.
claude-for-legal
The same pattern applied to legal work: reference agents, skills, and data connectors for in-house commercial, privacy, corporate, employment, litigation, regulatory, AI governance, and IP workflows. Anthropic also publishes life-sciences, healthcare, and claude-for-financial-advisors marketplaces on the same model.
A note on Cowork: many of these repos were built for Claude Cowork and their descriptions still say so. On September 16, 2026, Cowork and chat became one Claude, so the plugins now target Claude itself rather than a separate product.
Layer 5: CI/CD Automation
claude-code-action
The bridge between Claude and your CI/CD pipeline. It auto-detects the mode from your workflow context:
Interactive: Add @claude to any PR comment or issue, and Claude responds — reading code, suggesting fixes, or implementing changes directly.
Automated: Trigger via workflow_dispatch for scheduled tasks — nightly code reviews, PR labeling, security scanning.
- uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
# Claude responds to @claude mentions in PRsIt supports Anthropic API (API key, OAuth token, or workload identity federation), AWS Bedrock, Google Vertex AI, and Microsoft Foundry for authentication. The fastest way to set it up is to run /install-github-app in a Claude Code session.
claude-code-base-action
The lower-level building block. Where claude-code-action is opinionated (PR reviews, issue responses), base-action gives you raw Claude Code execution in CI.
Two things changed here. First, the repo is now an automated mirror of the base-action directory inside claude-code-action — file issues and PRs against the main repo. Second, the per-tool inputs were folded into a single claude_args string, and the published ref is @beta:
- uses: anthropics/claude-code-base-action@beta
with:
prompt: "Run all tests and fix any failures"
claude_args: '--allowedTools "Bash,Read,Write,Edit" --max-turns 20'
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}Use this when you need custom automation that doesn’t fit the standard patterns — running migrations, generating documentation, updating dependencies. It can also preinstall plugins and marketplaces via its plugins and plugin_marketplaces inputs.
Note the trust model: base-action is a thin wrapper with no actor permission checks. For workflows that process untrusted input (fork PRs, external comments), use claude-code-action instead.
Layer 6: Security & Monitoring
claude-code-security-review
An AI-powered security scanner that runs on every PR. Unlike pattern-matching tools (SAST), this uses Claude to understand semantic vulnerabilities:
- Injection attacks (SQL, command, LDAP, XXE)
- Auth bypass and privilege escalation
- Hardcoded secrets and data exposure
- Business logic flaws (race conditions, TOCTOU)
- Supply chain risks
It filters false positives automatically and comments findings directly on the PR. The action’s claude-model input defaults to empty, so it uses whatever Claude Code’s own default is — pin a model there only if you need a specific one.
claude-code-monitoring-guide
A complete observability setup: Prometheus + OpenTelemetry configuration, cost tracking by model, usage analytics, productivity metrics (PR count, commit frequency), and team adoption dashboards.
This is the “prove the ROI” toolkit — essential for enterprises evaluating Claude Code adoption. It’s a guide rather than a maintained tool, and hasn’t been revised since mid-2025, so treat the pricing figures in it as historical and check current rates on the costs page.
sandbox-runtime
srt enforces filesystem and network restrictions on arbitrary processes at the OS level, without a container — sandbox-exec on macOS, bubblewrap on Linux, plus proxy-based network filtering. It’s the sandboxing primitive Claude Code was built on, open-sourced as a beta research preview so the wider ecosystem can sandbox agents, local MCP servers, and bash commands too.
Layer 7: Learning & Onboarding
These repos form a natural learning path:
prompt-eng-interactive-tutorial
The step-by-step interactive guide to prompting techniques, and the live front door for learning. Anthropic’s older multi-course repo, courses, was archived in 2026 — its API fundamentals, real-world prompting, prompt evaluations, and tool-use modules are still readable there, but they’re frozen and favor long-retired models, so start here instead.
claude-cookbooks
Copy-paste recipes for specific tasks: classification, RAG, summarization, text-to-SQL, vision, sub-agents, and more. Jupyter notebooks you can run immediately, and the most actively maintained of the learning repos.
claude-quickstarts
Now 17 complete application templates, not the handful it launched with. The classics are still there — Customer Support Agent, Financial Data Analyst, Computer Use Demo, Autonomous Coding Agent — joined by Browser Use Demo, minimal Browser Toolset (browser_toolset_20260801) and Computer Toolset (computer_toolset_20260801) examples, computer-use best practices, and a large Managed Agents set: Chat SDK, CopilotKit/AG-UI, Daily Brief, Knowledge Wiki, Linear, MCP Server, Road Trip Planner, Sentry, and Slack.
The center of gravity has visibly shifted toward Managed Agents — agents that run on Anthropic’s infrastructure rather than yours.
devcontainer-features
One-line Claude Code setup for Dev Containers and GitHub Codespaces:
{
"features": {
"ghcr.io/anthropics/devcontainer-features/claude-code:1": {}
}
}Zero-friction onboarding in containerized environments.
How Everything Connects
Here’s the key insight: these aren’t 24 independent projects. They’re 24 components of one platform.
The data flow looks like this:
Developer learns (tutorial → cookbooks → quickstarts)
│
▼
Builds with API SDK (anthropic-sdk-python/ts)
│
▼
Upgrades to Agent SDK (agent-sdk-python/ts)
for autonomous agents
│
├──→ Uses Claude Code as runtime engine
│
├──→ Extends with Plugins & Skills
│ (plugins-official, plugins-community,
│ skills, knowledge-work, vertical repos)
│
├──→ Connects to external tools via MCP
│ (claude-ai-mcp, third-party servers)
│
└──→ Deploys to CI/CD
(claude-code-action, base-action)
│
├──→ Security scanning & sandboxing
│ (security-review, sandbox-runtime)
│
└──→ Monitoring & ROI
(monitoring-guide)The Constitution sits underneath everything, defining the behavioral boundaries.
The CLI tools (claude-code, ant) provide direct human interfaces — one agentic, one API-first.
The Demos show how all the pieces combine in real applications.
What This Means for Developers
If you’re just starting
Start with the prompt engineering tutorial → try Claude Code → experiment with cookbooks. You don’t need to understand the full ecosystem on day one.
If you’re building a product
Use the API SDK for simple integrations, upgrade to the Agent SDK when you need autonomous capabilities. Add MCP servers for external tool access. Study the demos and the Managed Agents quickstarts for architecture patterns.
If you’re running a team
Deploy claude-code-action for automated PR reviews. Add security-review for vulnerability scanning and sandbox-runtime if you want agents boxed in at the OS level. Use the monitoring guide to track ROI. Install knowledge-work-plugins to give every team member a domain-expert Claude.
If you’re extending the platform
The plugin format is just markdown and JSON — no code required. The skills spec is even simpler. Fork, customize, contribute back.
The Bigger Picture
What Anthropic is building isn’t just an AI model. It’s a developer platform with the same layered architecture you’d expect from AWS, Vercel, or GitHub:
- Compute layer (Claude models)
- SDK layer (API + Agent SDKs)
- Runtime layer (Claude Code)
- Protocol layer (MCP)
- Extension layer (Plugins + Skills)
- Automation layer (GitHub Actions)
- Observability layer (Monitoring + Security)
- Education layer (Tutorial + Cookbooks + Quickstarts)
Every layer builds on the one below. Every component has a clear responsibility. And the entire thing is open source.
The repos I’ve mapped here aren’t the end — they’re the foundation. The growth since this article first went up has been almost entirely at the edges: more plugins, more vertical marketplaces, more Managed Agents quickstarts. The layers themselves have held.
The developers who understand this architecture — who see the 24 repos as one system — will be the ones who build the most powerful things with it.
All 24 repositories are available at github.com/anthropics. Repository facts in this article were re-verified against the GitHub API on October 21, 2026.