Model¶
Platforms:
claudeopenaigeminim365-copilot
What a Model Is¶
A model is the AI engine that powers everything. It's a system trained on data that takes input and produces output through learned patterns — generating text, writing code, analyzing images, or reasoning through complex problems.
Every other building block depends on a model. Prompts steer it. Context informs it. Projects organize work for it. Skills package routines for it. Agents orchestrate it. MCP connects it to external systems. Without a model, the other blocks have nothing to run on.
Key Characteristics¶
- Trained on data — a model's knowledge comes from its training data, with a cutoff date after which it has no information
- Come in capability tiers — from fast, lightweight models for simple tasks to deep reasoning models for complex analysis
- Have defined context windows — how much information (measured in tokens) a model can process at once
- Vary by modality — some handle only text, others work with code, vision, audio, or multiple modalities together
Model Capabilities¶
Different models excel at different things. Here are the key capability dimensions to consider:
| Capability | What It Means | Example Tasks |
|---|---|---|
| Reasoning | Complex analysis, multi-step logic, nuanced judgment | Strategy analysis, research synthesis, debugging complex systems |
| Code generation | Writing, debugging, and explaining code | Building features, fixing bugs, code review |
| Multimodal | Processing or generating images, audio, or video | Analyzing charts, describing photos, transcribing audio |
| Speed | Fast response for simple, high-volume tasks | Summarization, formatting, classification, triage |
| Context window | How much input the model can handle at once | Processing long documents, large codebases, multi-file analysis |
| Tool use | Calling functions, APIs, and external tools | Running code, searching the web, querying databases |
When to Use It (Model Selection Guidance)¶
Choosing the right model for the task is one of the highest-leverage decisions you can make:
| Task Type | Recommended Model Tier | Why |
|---|---|---|
| Simple tasks (summarization, formatting, classification) | Fast, lightweight models | Speed and cost matter more than depth |
| Complex analysis (research, strategy, multi-step reasoning) | Reasoning-capable models | Accuracy and depth matter more than speed |
| Visual tasks (image analysis, diagram interpretation) | Multimodal models | The task requires understanding non-text inputs |
| Code-heavy work (building features, debugging, refactoring) | Code-optimized models | Specialized training produces better code output |
| High-volume automation (batch processing, triage) | Fast models with tool use | Throughput and cost-efficiency are priorities |
Cost-quality tradeoff
Not every task needs the most powerful model. Using a fast model for simple tasks and reserving reasoning models for complex ones saves cost without sacrificing quality. Many platforms let you route different tasks to different models within the same workflow.
Foundational Concepts¶
These concepts help you understand what a model is and how it works:
Parameters — The internal weights that define a model's learned patterns. More parameters generally means more capability, but also more computational cost. You don't set parameters — they're determined during training.
Tokens — How models measure input and output. A token is roughly 3-4 characters of English text. Models have limits on how many tokens they can process (input) and generate (output) per request.
Context window — The total number of tokens a model can handle in a single interaction, including both the input you provide and the output it generates. Larger context windows let you work with longer documents and more complex inputs.
Temperature — A setting that controls randomness in outputs. Low temperature (0.0) produces more deterministic, focused responses. High temperature (1.0+) produces more creative, varied responses. Most platforms default to a balanced setting.
Training data and knowledge cutoff — Models learn from data up to a specific date. They don't know about events, products, or information published after their cutoff. This is why context (providing current information) is essential for tasks involving recent data.
Fine-tuning — Customizing a pre-trained model on your specific data to improve performance for your domain. Most users don't need to fine-tune — prompt engineering and context are usually sufficient — but it's available for specialized use cases.
Where to Find Models¶
| Source | What's Available | Best For |
|---|---|---|
| Anthropic (Claude) | Claude model family across capability tiers | Reasoning, code, analysis, long context |
| OpenAI | GPT and reasoning model families | General purpose, reasoning, multimodal |
| Gemini model family | Multimodal, Google ecosystem integration | |
| Open-source hubs (Hugging Face) | Thousands of community and enterprise models | Custom deployment, fine-tuning, specialized tasks |
Open-source vs. proprietary
Proprietary models (Claude, GPT, Gemini) are accessed via APIs and platforms — you don't host them yourself. Open-source models (Llama, Mistral, and others on Hugging Face) can be downloaded and run on your own infrastructure, offering more control but requiring more technical setup.
Platform Implementations¶
| Platform | How It Works |
|---|---|
| Claude | Multiple model tiers (fast, balanced, reasoning); select via model picker in conversation or API parameter |
| OpenAI (ChatGPT) | Multiple model tiers (fast, balanced, reasoning); select via model picker in conversation or API parameter |
| Gemini | Multiple model tiers (fast, balanced); select via model picker in conversation or API parameter |
| M365 Copilot | Models managed by Microsoft; limited user selection based on Copilot context |
Relationship to Other Blocks¶
Model is the foundation — the engine everything else runs on:
- Prompts steer the model — telling it what to do
- Context informs the model — giving it knowledge it wasn't trained on
- Projects organize work for the model — grouping instructions and context
- Skills package routines for the model — reusable workflows it executes
- Agents orchestrate the model — directing it through multi-step tasks
- MCP connects the model — giving it access to external tools and data
- APIs expose the model — letting code call it programmatically
- SDKs wrap the model — providing frameworks for agent orchestration and tool use
Related¶
- Agentic Building Blocks — Model in the context of all nine building blocks
- AI Use Cases — what teams build with these blocks, organized by six primitives
- Prompts — the instructions that steer the model
- Context — the knowledge that informs the model
- Projects — workspaces that organize work for the model
- Skills — reusable routines the model executes
- Agents — autonomous systems that orchestrate the model
- MCP — connectors that extend the model's reach
- Platforms — platform-specific model guides