AI coding tools explained

January 17, 2026

AI Coding Tools: Models, Products & Agents Explained

A clear breakdown of the terminology and relationships in the AI coding landscape.

The Three Layers

graph TD
    P["🎯 Products"]

    subgraph "What you use"
        P1["Claude.ai"]
        P2["Claude Code"]
        P3["GitHub Copilot"]
        P4["Cursor"]
    end

    A["🛠️ Agent Features"]

    subgraph "Models"
        M1["Claude"]
        M2["GPT-4/5"]
        M3["Gemini"]
    end

    P --> P1
    P --> P2
    P --> P3
    P --> P4

    P1 -.-> M1
    P2 -.-> M1
    P2 --> |Has agents| A
    P3 -.-> M1
    P3 -.-> M2
    P3 -.-> M3
    P3 --> |Has agents| A
    P4 -.-> M1
    P4 -.-> M2
    P4 --> |Has agents| A

Models

Models are the AI “brains” — trained neural networks that process input and generate output.

Anthropic (Claude)

Version numbers indicate generation: Claude 3.5 Sonnet → Claude 4 Sonnet → Claude Opus 4.5

OpenAI (GPT)

Google (Gemini)

Products

Products are the interfaces/tools that let you interact with models.

graph TD
    subgraph "Product Categories"
        CA["🤖 Claude.ai<br/>Web/mobile chat"]
        CC["💻 Claude Code<br/>CLI tool"]
        GC["🔧 GitHub Copilot<br/>IDE extension"]
        CU["✨ Cursor<br/>AI IDE"]
    end

    subgraph "Models Supported"
        M1["Claude<br/>(Anthropic)"]
        M2["GPT<br/>(OpenAI)"]
        M3["Gemini<br/>(Google)"]
    end

    CA -->|Claude| M1
    CC -->|Claude| M1
    GC -->|Claude, GPT,<br/>Gemini| M1
    GC -->|Multi-model| M2
    GC -->|Multi-model| M3
    CU -->|Claude, GPT| M1
    CU -->|Multi-model| M2

Comparison

Agents

An agent is when you give a model the ability to take actions and iterate autonomously.

Regular vs Agent Interaction

sequenceDiagram
    participant U as User
    participant M as Model

    Note over U,M: Regular Chat
    U->>M: Ask question
    M->>U: Response
    Note over U,M: Done

    Note over U,M: Agent Mode
    U->>M: Give task
    loop Until complete
        M->>M: Think
        M->>M: Take action (edit file, run command)
        M->>M: Observe result
        M->>M: Decide next step
    end
    M->>U: Task complete

Agent = Model + Tools + Loop

graph TD
    Task["📝 User Task<br/>'Fix the failing tests'"]
    Model["🧠 Model<br/>Thinks & Decides"]
    Tools["🛠️ Tools<br/>Edit files, run commands"]
    Observe["👁️ Observe<br/>Check result"]
    Done{Complete?}
    Result["✅ Final Result"]

    Task --> Model
    Model --> Tools
    Tools --> Observe
    Observe --> Done
    Done -->|No| Model
    Done -->|Yes| Result

Example: “Fix the failing tests”

GitHub Copilot Deep Dive

Two Agent Flavors

1. Agent Mode (in IDE)

   • Interactive, you watch it work
   • Edits files, runs commands, auto-corrects
   • Available in VS Code, JetBrains, Xcode, Eclipse

2. Coding Agent (async)

   • Assign a GitHub Issue to Copilot
   • Works in background via GitHub Actions
   • Opens draft PR when done
   • You review and iterate

flowchart TD
    subgraph "Agent Mode<br/>(Interactive)"
        AM1["🔄 You prompt"]
        AM2["🤖 Copilot works"]
        AM3["👀 You see changes"]
        AM4["✅ Approve/adjust"]
        AM1 --> AM2 --> AM3 --> AM4
    end

    subgraph "Coding Agent<br/>(Async)"
        CA1["📋 Assign Issue"]
        CA2["⚙️ Works in background"]
        CA3["📝 Draft PR created"]
        CA4["👀 You review"]
        CA5["🎯 Merge"]
        CA1 --> CA2 --> CA3 --> CA4 --> CA5
    end

Model Selection in Copilot

Cost (Premium Requests)

Quick Reference

mindmap
  root((AI Coding))
    **Models**
      Anthropic
        Opus
        Sonnet
        Haiku
      OpenAI
        GPT-5
        GPT-4o
        o3/o4
      Google
        Gemini Pro
        Gemini Flash
    **Products**
      Claude.ai
      Claude Code
      GitHub Copilot
      Cursor
    **Agents**
      Model + Tools + Loop
      Autonomous execution
      GitHub Coding Agent
      Agent Mode

TL;DR

• Models = AI brains (Claude Opus, GPT-5, Gemini)
• Products = Tools to use them (Claude.ai, Copilot, Cursor)
• Agents = Model + tools + autonomous loop
• GitHub Copilot can use multiple models; Claude Code only uses Claude
• Same model (e.g., Claude Opus) can power different products