The AI Ecosystem Map

Why This Is So Confusing

The same words get reused across completely different layers of the stack. "Claude" is a company, a model family, a chat app, a coding CLI, a desktop app, a VS Code extension, and a web product. "Copilot" means GitHub Copilot (an IDE extension), Microsoft Copilot (a chat app), and GitHub Copilot coding agent (an autonomous PR writer) — all from different teams.

This page gives every confusing term a precise home in a six-layer map. Once you know which layer a thing lives in, the naming makes sense.

Layer 1: AI Labs          — who trains the models
Layer 2: Foundation Models — the actual AI weights
Layer 3: Consumer Apps    — chat UIs for everyday use
Layer 4: Developer Tools  — coding IDEs, extensions, CLIs
Layer 5: Frameworks       — SDKs for building AI systems
Layer 6: Inference Infra  — where the model actually runs

Layer 1 — AI Labs (Who Trains the Models)

These are the companies that spend billions training foundation models. A lab is not an app — it is the upstream source for the weights that power everything else.

Key point: Labs and models are not the same thing. Anthropic is the lab. Claude is the model. Claude.ai is the app. All three words get used interchangeably in conversation, which is where the confusion starts.

Layer 2 — Foundation Models (The AI Brain)

A foundation model is a set of trained weights — not an app, not a service, not a chatbot. The same weights can power a chat interface, a coding CLI, a VS Code extension, and an API endpoint simultaneously.

Core insight: GPT-5.4 is a model. ChatGPT is an app that uses GPT-5.4. Cursor is another app that also uses GPT-5.4. GitHub Copilot can use it too. The same underlying model, accessed through completely different surfaces.

OpenAI GPT-5.x Family (as of April 23, 2026 — GPT-5.5 released today)

Anthropic Claude 4.x Family

Google Gemini 3.x Family

Other Notable Models (April 2026)

Layer 3 — Consumer AI Apps (Chat for Everyday Use)

These are the products a non-technical person opens to talk to an AI. No coding, no API keys, no setup.

These are all chatbots. They differ in which model they use, what live data they can access (web, email, calendar), and what extra features they layer on top (image generation, voice mode, memory, etc.).

Consumer App Subscription Plans (April 2026)

Consumer AI apps use flat-rate subscription pricing — you pay a fixed monthly fee for access to the app and its features, not per message sent. This is fundamentally different from API pricing (see Layer 6), where you pay per token consumed and get raw model access.

OpenAI / ChatGPT

Anthropic / Claude.ai

Google / Gemini

Subscription ≠ API access. None of these consumer plans give you programmatic API access. If you want to call a model from your own code or product, you need a separate API account with pay-per-token billing — see Layer 6.

Layer 4 — Developer / Coding Tools

This is where the naming chaos peaks. The same capability (an AI that reads and edits your code) comes packaged as four completely different form factors:

                    ┌─────────────────────────────────┐
                    │      Foundation Model            │
                    │  (GPT-5.5, Claude Opus 4.7, ...) │
                    └──┬──────┬──────────┬────────┬───┘
                       │      │          │        │
                  ┌────▼──┐ ┌─▼──────┐ ┌▼──────┐ ┌▼──────────┐
                  │AI-Native│ │IDE     │ │Terminal│ │Web/Desktop│
                  │IDE     │ │Extension│ │CLI    │ │Coding App │
                  │(new    │ │(add-on │ │(no GUI)│ │(GUI agent)│
                  │editor) │ │to your │ │       │ │           │
                  │        │ │editor) │ │       │ │           │
                  └────────┘ └────────┘ └───────┘ └───────────┘

4a — AI-Native IDEs (replaces your editor)

You install this instead of VS Code. It's a complete editor built from the ground up around AI.

4b — IDE Extensions (adds AI to your existing editor)

You keep VS Code (or JetBrains, or Xcode) and install a plugin. Zero disruption to your current workflow.

4c — Terminal / CLI Agents (lives in your terminal, no GUI)

You type a command in your terminal. The agent reads and writes your actual local files, runs shell commands, commits to git — all without any visual editor. Maximum control, steepest learning curve.

4d — Web / Desktop Coding Agent Apps (GUI wrappers for agent workflows)

Dedicated apps for coding tasks — not general-purpose chat. They give you a visual interface to the same agent capability you'd run in the terminal.

"Claude Code" is one brand name for four different surfaces: CLI, VS Code extension, Desktop App, and web. They share the same Claude model and billing account but have very different UX and capability levels. The CLI is the most powerful (multi-agent, unlimited sessions, full MCP, full filesystem). The web version is the most restricted (cloud sandbox only).

Layer 5 — Agentic Frameworks (SDKs for Building AI Systems)

These are developer libraries for engineering teams building AI-powered applications. They are not end-user tools.

If you are a developer writing Python or TypeScript to build the next Claude Code, Cursor, or an internal AI workflow — this is your layer.

You almost never need a framework if you are an end-user. Frameworks are for the team building the product you will eventually use. If you are deciding between Cursor and GitHub Copilot, this layer is not relevant to you.

Layer 6 — Inference Providers (Where the Model Actually Runs)

Inference providers are usually invisible to end users. They are the cloud services that actually host the model weights and serve the responses. A single lab may run its own inference (Anthropic API) or license to third-party providers (Mistral on Azure, Claude on Bedrock).

API Pricing: On-Demand Pay-Per-Token (April 2026)

APIs charge per million tokens (MTok) — input (your prompt) and output (the model's response) are billed separately. There is no subscription; you pay only for what you use. This makes APIs ideal for variable workloads, automation, and building products.

OpenAI API

Anthropic API

Google Gemini API (via AI Studio or Vertex AI)

†Lower price for prompts ≤200K tokens; higher for prompts >200K tokens.

Free API tiers: Google AI Studio offers 25 Gemini 2.5 Pro requests/day and 1,500 Flash requests/day free — generous for development and testing. Anthropic gives new accounts small free credits. OpenAI has no free tier but has very cheap nano/mini models.

Subscription vs. API breakeven: At heavy daily use (e.g., 8+ hours of Claude Code agentic work), the Claude Max 20× subscription at $200/month is typically cheaper than equivalent API token spend. For lighter, variable, or bursty usage, pay-as-you-go API is usually more cost-effective. Model your actual usage pattern before committing to either.

Common Confusions, Resolved

"Anthropic vs. Claude"

• Anthropic = the company (lab). Trains the models.
• Claude = the model family (Opus, Sonnet, Haiku). The weights.
• Claude.ai = the consumer chat app (Layer 3).
• Claude Code = the developer coding tool (Layer 4), which itself ships in four forms.

"ChatGPT vs. GPT-5.4 vs. GPT-5.5"

• GPT-5.4 / GPT-5.5 = models (Layer 2). The AI brain.
• ChatGPT = the consumer app (Layer 3) that uses GPT-5.x.
• Cursor, GitHub Copilot, and your custom app can also use the same GPT-5.4 model via the API.

"ChatGPT (the app) vs. OpenAI API — same model, very different harness"

This is one of the most practically important distinctions to understand.

Same model, completely different experience. ChatGPT and the OpenAI API both use GPT-5.x weights — but ChatGPT wraps the model in a thick application layer ("harness") that adds features, enforces limits, and abstracts away control. The API gives you the raw model.

Key insight: A developer paying $20/month for ChatGPT Plus and a developer paying $20 in API tokens are not getting the same thing. The Plus subscriber gets a polished product with baked-in tools and routing but less control. The API caller gets raw model access with full control but must build the tooling layer themselves. For many developer use cases, the API is actually cheaper per effective output — teams that switch from ChatGPT to the API often cut costs 30–50% by routing simpler tasks to cheaper models explicitly.

ChatGPT's auto-router: Since early 2026, ChatGPT uses an automatic routing layer that picks between GPT-5.3 Instant and GPT-5.4 Thinking based on query complexity. You can override this by manually selecting a model, but the default is opaque. The API has no such routing — what you ask for is exactly what runs.

"Claude Code CLI vs. Claude Code Desktop vs. Claude Code extension"

All three are branded "Claude Code." All use Claude models. They are very different:

"Codex vs. ChatGPT"

Both are OpenAI products. ChatGPT is a general-purpose assistant. Codex is specifically for autonomous coding tasks. GPT-5.3-Codex and GPT-5.5 are the models inside Codex. "Codex" by itself means the product/app (browser + CLI + extension).

"Cursor vs. GitHub Copilot"

• Cursor = a whole new IDE. You switch away from VS Code (though it feels identical). AI is woven into every keystroke.
• GitHub Copilot = a plugin. You stay in VS Code (or JetBrains, or Xcode). Lower disruption, lower cost ($10/month vs. $20/month).
• Both can use the same underlying GPT-5.x or Claude models.

"LangChain vs. Claude Code"

• LangChain / LangGraph = a developer framework (Layer 5) for building AI apps. Engineering tool.
• Claude Code = an end-user developer tool (Layer 4). A product you use.
• A software team might use LangChain to build something like Claude Code for their company.

"IDE vs. IDE Extension vs. CLI"

• IDE = the whole editor. Cursor and Zed are IDEs. You open them instead of VS Code.
• IDE Extension = a plugin installed inside your existing editor. GitHub Copilot is an extension.
• CLI = runs in a terminal window. No visual editor at all. Claude Code CLI is a CLI.

"Gemini vs. Google"

• Google / Google DeepMind = the lab (Layer 1).
• Gemini = the model family (Layer 2): Gemini 3.1 Pro, Gemini 3 Flash, etc.
• Gemini (the app) = the consumer chat product (Layer 3), like ChatGPT but from Google.
• Gemini Code Assist = the IDE extension (Layer 4).
• Google Antigravity = a new AI-native IDE (also Layer 4).
• Same word, four different layers.

How the Layers Connect

┌─────────────────────────────────────────────────────────────────┐
│  Layer 6: Inference Providers                                   │
│  (OpenAI API · Anthropic API · Bedrock · Vertex · OpenRouter)  │
└──────────────────────────────┬──────────────────────────────────┘
                               │ serve weights to
┌──────────────────────────────▼──────────────────────────────────┐
│  Layer 2: Foundation Models                                     │
│  (GPT-5.5 · Claude Opus 4.7 · Gemini 3.1 Pro · Kimi K2.5 ...)  │
└────────────┬──────────────────────────────────────┬────────────┘
             │ power                                 │ power
┌────────────▼───────────────┐   ┌──────────────────▼───────────┐
│  Layer 3: Consumer Apps    │   │  Layer 4: Developer Tools    │
│  (ChatGPT · Claude.ai ·    │   │  (Cursor · Copilot ·         │
│   Gemini · Grok ...)       │   │   Claude Code · Codex ...)   │
└────────────────────────────┘   └──────────────────────────────┘
                                                  ▲
                                                  │ built with
                                 ┌────────────────┴─────────────┐
                                 │  Layer 5: Frameworks         │
                                 │  (LangGraph · CrewAI ·       │
                                 │   AutoGen · PydanticAI ...)  │
                                 └──────────────────────────────┘
     ┌─────────────────────────────────────────────────────────┐
     │  Layer 1: AI Labs (train and update the models)         │
     │  (OpenAI · Anthropic · Google · Meta · xAI · Mistral …) │
     └─────────────────────────────────────────────────────────┘

Quick Reference: What Am I Looking At?

See Also

• Model Context Protocol (MCP) — the standard that connects Layer 4 tools to external tools and data
• Agent-to-Agent Protocol (A2A) — how Layer 4/5 agents communicate with each other
• 6 Agent Design Patterns — the recurring patterns used in Layer 5 frameworks
• Managed Agent Platforms — Comparative Overview — deeper dive into hosted agent runtimes