Agentic AI Building Blocks
Platforms:
claudeopenaigeminim365-copilot
Overview
Section titled “Overview”The AI building blocks are a shared vocabulary for describing the components of any AI workflow. Whether you’re writing a single prompt, calling a model from code, or orchestrating a multi-agent pipeline, every AI workflow is assembled from some combination of these building blocks.
Fifteen building blocks, in four layers. A layer is a group of blocks that do the same kind of job:
| Layer | Its job | Building blocks |
|---|---|---|
| Intelligence | The reasoning core: where the work is understood and decided | Model, Context, Memory, Project |
| Orchestration | The director: turns your intent into coordinated work | Prompt, Skill, Agent, Harness |
| Integration | The connections: link the AI to your tools and data | MCP, API, SDK, CLI |
| Governance | The guardrails: keep AI work visible, accountable, and trustworthy | Registry, Observability, Evaluation |
One way to hold the four layers in your head is to think of a new team member. Intelligence is what they know and how well they think. Orchestration is how their work is directed: a one-off request, a written procedure, or a goal they pursue on their own. Integration is the access they have: the systems they can log into. Governance is how you keep track of what they are doing and check that it is good.
These are platform-agnostic concepts. Every major AI platform implements them, though the names and interfaces differ. Understanding the blocks gives you a mental model that transfers across tools — you can evaluate any platform by asking how it handles each block, from models and prompts to connections, observability, and evaluation.
Intelligence
Section titled “Intelligence”The persistent foundation: engine, knowledge, and workspace powering every interaction.
The AI engine that processes inputs and generates outputs. Models are trained on data and come in different capability tiers — from fast, lightweight models for simple tasks to deep reasoning models for complex analysis.
Key characteristics:
- The foundation all other blocks operate on — every AI interaction requires a model
- Come in capability tiers: fast models for speed, reasoning models for depth
- Have defined context windows and vary by modality (text, code, vision, audio)
When to use it: Every AI interaction uses a model. The key decision is choosing the right model — matching model capabilities to your task requirements.
Example: Using a fast model for high-volume email classification, and a reasoning model for complex strategy analysis that requires nuanced judgment.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Multiple model tiers (fast, balanced, reasoning); select via model picker or API |
| OpenAI (ChatGPT) | Multiple model tiers (fast, balanced, reasoning); select via model picker or API |
| Gemini | Multiple model tiers (fast, balanced); select via model picker or API |
| M365 Copilot | Models managed by Microsoft; limited user selection |
Relationship to other blocks: Model is the engine — prompts steer it, context informs it, skills package routines for it, agents orchestrate it, MCP connects it to external systems, APIs expose it to code, and SDKs provide frameworks for orchestrating it.
Context
Section titled “Context”Unique knowledge (not in models) required by the agentic workflow for execution. These are information from sources such as docs, databases, and markdown files.
Key characteristics:
- Provides knowledge the model doesn’t have — your data, your docs, your domain
- Can be inline (pasted into the conversation), attached as files, or pre-loaded in a project
- Improves output quality by grounding the model in your specific domain
When to use it: When the model needs information it wasn’t trained on — your company’s style guide, a product spec, customer data, or examples of desired output format.
Example: Attaching your brand voice guidelines and three sample blog posts before asking the model to draft a new one.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | File attachments, project knowledge base, conversation history |
| OpenAI (ChatGPT) | File uploads, Workspace Agent files, conversation history |
| Gemini | File uploads, Google Drive integration, NotebookLM sources |
| M365 Copilot | Microsoft Graph (emails, files, meetings), attached documents |
Relationship to other blocks: Context makes prompts smarter. Projects organize context persistently so you don’t re-upload it every time.
Project
Section titled “Project”Self-contained workspaces with their own chat histories and knowledge bases that set custom instructions applying to all conversations within the project.
Key characteristics:
- Organizes related resources in one place so they persist across conversations
- Sets custom instructions that apply to every conversation in the project
- Reduces setup time: start a new conversation with everything already in place
When to use it: When you run the same type of workflow repeatedly and want to avoid re-uploading context and re-explaining instructions every time.
Example: A “Weekly Client Reports” project that contains your report template, client data, brand guidelines, and standing instructions for tone and format.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Claude Projects (with project knowledge and custom instructions) |
| OpenAI (ChatGPT) | Projects in ChatGPT, or Workspace Agents for configured, reusable bundles |
| Gemini | Gems (with custom instructions and uploaded context); Gemini Enterprise agents for shared, configured workflows |
| M365 Copilot | Copilot agents with knowledge sources and instructions |
Relationship to other blocks: Projects are containers — they hold the prompts, context, and skills a workflow needs, making the whole package reusable.
Memory
Section titled “Memory”Accumulated knowledge from past interactions — preferences, decisions, facts, and patterns that the AI retains and retrieves when relevant. Memory makes AI persistent rather than stateless.
Key characteristics:
- System-managed, not user-curated — the AI decides what to remember
- Persists across conversations — survives session boundaries
- Grows over time — more interactions produce richer memory
When to use it: When repeating context to the AI is friction — preferences, project conventions, communication style — or when the AI should adapt to how you work over time.
Example: After several conversations about a project, the AI remembers your preferred report format, the client’s communication preferences, and that last week’s deliverable was delayed — without you re-explaining any of it.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Claude memory, CLAUDE.md project memory, conversation continuity |
| OpenAI (ChatGPT) | ChatGPT Memory, custom instructions persistence |
| Gemini | Conversation memory, Gems with learned preferences |
| M365 Copilot | Microsoft Graph as implicit memory, organizational knowledge |
Relationship to other blocks: Memory complements context — context is knowledge you provide, memory is knowledge the AI accumulates. Projects organize context; memory adds learned persistence on top.
Orchestration
Section titled “Orchestration”The execution layer: instructions, routines, and autonomous agents that direct and do the work.
Prompt
Section titled “Prompt”Instructions you provide to an AI in natural language during a conversation. Prompts are ephemeral, conversational, and reactive — you provide context and direction in the moment.
Key characteristics:
- The most fundamental building block — every AI interaction starts with a prompt
- Can range from a single sentence to a detailed multi-section instruction
- Ephemeral by default: conversational and reactive, used in the moment
When to use it: Any time you interact with an AI model. A good prompt is sufficient for many tasks without needing other blocks.
Example: “Summarize this quarterly sales report in three bullet points, highlighting the biggest change from last quarter.”
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Message in conversation, system prompt, or project instructions |
| OpenAI (ChatGPT) | Message in conversation, system prompt, or Workspace Agent instructions |
| Gemini | Message in conversation or Gem instructions |
| M365 Copilot | Message in chat, or prompt within a Copilot agent |
Relationship to other blocks: Prompts are the foundation — context enhances them, skills package them for reuse, and agents chain them together.
Folders containing instructions, scripts, and resources that the AI discovers and loads dynamically when relevant to a task. Skills are now an open standard and being adopted broadly.
Key characteristics:
- Encapsulates a specific capability: instructions, context, and output format bundled together
- Invocable two ways: auto-triggered when relevant, or invoked directly with a slash command
- Reusable across conversations, shareable with others, and becoming an open standard
When to use it: When you find yourself writing the same prompt repeatedly, or when a workflow step is well-defined enough to package as a repeatable routine.
Example: A “Draft Meeting Recap” skill that takes meeting notes as input and produces a formatted summary with action items, decisions, and follow-ups — in your team’s standard format every time.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Claude Code Skills (SKILL.md files with instructions and references) |
| OpenAI (ChatGPT) | Skills in ChatGPT, Workspace Agents, and Codex CLI (open agentskills.io format) |
| Gemini | Gemini CLI skills (agentskills.io format); Gems with structured instructions |
| M365 Copilot | Copilot agent actions, Power Automate flows triggered by Copilot |
Relationship to other blocks: Skills are upgraded prompts — they package a prompt with its context into something reusable. Agents can invoke skills as part of multi-step workflows.
A system where an LLM controls workflow execution to achieve a goal.
Key characteristics:
- Plans its own approach: breaks goals into steps and decides which tools to use
- Uses tools: can read files, search the web, run code, call APIs
- Iterates: evaluates its own output, handles errors, and adjusts course
When to use it: When a workflow requires multiple steps, tool use, or decision-making that would be tedious to manage manually through individual prompts.
Example: A research agent that takes a topic, searches multiple sources, synthesizes findings, fact-checks claims, and produces a structured report — deciding on its own which sources to consult and how deep to go.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Claude Code agents (autonomous tool-using sessions), Cowork agents |
| OpenAI (ChatGPT) | Workspace Agents with connectors and skills, Assistants API with tools |
| Gemini | Gemini Enterprise Agent Designer (no-code/visual), Agent Development Kit on Vertex AI, Gemini with extensions |
| M365 Copilot | Copilot agents with plugins and connectors |
Relationship to other blocks: Agents orchestrate the other blocks — they use prompts, draw on context, invoke skills, and connect to external systems through MCP. Every agent runs inside a harness.
Harness
Section titled “Harness”The software wrapped around a model that turns it into a working agent: the tool access, the memory, and the loop that keeps the work going. In short, agent = model + harness. If the model is the brain, the harness is the body that uses the tools and keeps track of the work.
Key characteristics:
- Runs the agent loop: sends the model the task, carries out the tool calls it asks for, feeds the results back, and repeats until the work is done
- Decides what the model sees: which instructions, files, memory, and tool results go into each step
- Supplies the tools and permissions: file access, web search, connectors, and what needs your approval before it runs
When to use it: You always use one. Every time you work with an AI app or an agent, a harness is running it. The decision is which harness fits the work: an everyday app for knowledge work, a coding tool for building software, or an SDK when you build your own.
Example: The same model can draft a report in the Claude app and refactor a codebase in Claude Code. The model is identical; the harness around it supplies different tools, different context, and a different loop. When an agent goes wrong, the cause is often the harness rather than the model: context that got lost, the wrong tool, or no way to recover from an error.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | The Claude app for everyday work; Claude Code for building software; the Claude Agent SDK to build your own |
| OpenAI (ChatGPT) | ChatGPT (including agent mode) for everyday work; Codex for building software; the Agents SDK to build your own |
| Gemini | The Gemini app for everyday work; Gemini CLI for building software; the Agent Development Kit to build your own |
| M365 Copilot | M365 Copilot and Copilot agents for everyday work; GitHub Copilot for building software; the M365 Agents SDK to build your own |
Relationship to other blocks: The harness is what makes a model into an agent. It loads context and memory, invokes skills, and connects to external systems through MCP and CLIs. SDKs are toolkits for building your own harness.
Integration
Section titled “Integration”The connection layer: protocols, interfaces, and frameworks that bridge AI to external systems and code.
MCP (Model Context Protocol)
Section titled “MCP (Model Context Protocol)”An open standard for connecting AI assistants to external systems where data lives — content repositories, business tools, databases, and development environments.
Key characteristics:
- Bridges the gap between the AI and the outside world where your data lives
- Open standard: one integration pattern that works across compatible platforms
- Enables read and write operations: the AI can both retrieve information and take actions
When to use it: When the AI needs to interact with external systems — reading from a database, posting to Slack, creating tasks in a project management tool, or accessing live data.
Example: An MCP connector to your CRM that lets the AI look up client history, check deal status, and log meeting notes — all within the conversation.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | MCP servers (local or remote) connected via Claude Code or Claude Desktop |
| OpenAI (ChatGPT) | Function calling, connectors in Workspace Agents, Assistants API tools |
| Gemini | Extensions and function calling |
| M365 Copilot | Connectors, plugins, Power Platform integrations |
Relationship to other blocks: MCP extends what agents and skills can do by connecting them to external systems. Without MCP, the AI is limited to what’s in the conversation.
Programmatic interfaces for accessing AI models and cloud services. The code-first way to interact with AI — send a request, get a response.
Key characteristics:
- Stateless request/response pattern — each call is independent
- Authentication via API keys with usage-based billing
- Platform-agnostic — any language that can make HTTP requests can call an API
When to use it: When you need to integrate AI into an application, automate workflows programmatically, or access model capabilities beyond what the chat UI provides.
Example: Calling the Claude API from a Python script to classify 1,000 customer support tickets overnight, or calling a search API to enrich an agent’s research.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Anthropic REST API with Messages endpoint; Python and TypeScript SDKs |
| OpenAI (ChatGPT) | REST API with Chat Completions endpoint; Python and TypeScript SDKs |
| Gemini | REST API with generateContent endpoint; Python SDK; Vertex AI for enterprise |
| M365 Copilot | Azure AI Services REST APIs; .NET, Python, Java SDKs |
Relationship to other blocks: API is the programmatic bridge — it’s how you call models from code, and SDKs abstract over it. MCP servers often wrap APIs to give agents standardized access.
Frameworks and toolkits that provide abstractions for building AI workflows in code. Where APIs give you raw access, SDKs give you patterns and structure.
Key characteristics:
- Provide higher-level abstractions for tool use, memory, and multi-agent coordination
- Handle orchestration logic — planning, routing, error recovery
- Opinionated about patterns — agent loops, handoffs, guardrails
When to use it: When you’re building agents or multi-step workflows in code and want established patterns for tool use, memory management, or multi-agent coordination rather than wiring everything from scratch.
Example: Using the Claude Agent SDK to build a research agent with tool use and memory, or LangGraph to orchestrate a multi-agent pipeline with handoffs.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Agent SDK (Python, TypeScript) for agents with tool use, handoffs, and guardrails |
| OpenAI (ChatGPT) | Agents SDK (Python, TypeScript) for agents with function calling, handoffs, and tracing |
| Gemini | Agent Development Kit (ADK) for agents on Vertex AI with Google Cloud integrations |
| M365 Copilot | M365 Agents SDK (.NET, Python, TypeScript) for agents deployed to Microsoft 365 surfaces |
Relationship to other blocks: SDKs orchestrate models, abstract over APIs, and implement the agent concept in code. They integrate with MCP for external system access and formalize patterns like tool use and handoffs.
Terminal-native interfaces for interacting with AI. Instead of using a browser-based chat or calling an API from code, you work with AI directly from the command line — the same environment where you run commands, manage files, and write code.
Key characteristics:
- Terminal-native — runs where you already work, with full file-system access
- Scriptable — supports headless mode for automation, CI/CD, and scheduled tasks
- Extensible — supports plugins, skills, hooks, and MCP server connections
When to use it: When you’re working with AI in the terminal — coding, debugging, automating tasks via shell scripts or CI pipelines, or running scheduled AI jobs without a chat window.
Example: Using Claude Code to refactor a module — it reads the code, proposes changes, runs tests, and commits the result. Or running a CLI in headless mode in CI to generate release notes from git history on every push.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Claude Code — interactive + headless modes, tool use, skills, plugins, MCP integration |
| OpenAI (ChatGPT) | Codex CLI — interactive + headless modes, file editing, sandboxed execution |
| Gemini | Gemini CLI — interactive mode, Google Cloud integrations, MCP support |
| M365 Copilot | GitHub Copilot CLI — command suggestions, shell integration |
Relationship to other blocks: CLIs are the terminal-native interaction layer — they abstract over APIs to give humans (and scripts) a conversational interface to AI, with file-system awareness, tool use, and MCP integration built in.
Governance
Section titled “Governance”The guardrail layer: catalogs, visibility, and measurement that keep AI work accountable and trustworthy.
Registry
Section titled “Registry”A catalog of every AI workflow you run, the business processes they serve, and the skills and agents that power them. A registry is how you always know what you have, who owns it, and what it depends on.
Key characteristics:
- One record per workflow: what it does, what triggers it, how autonomous it is, and its current status
- Links each workflow to the process it serves and the building blocks it uses
- Kept as files you own, so it works across AI platforms and an AI can read and update it
When to use it: As soon as you rely on more than a handful of AI workflows, or share them with a team. Without a registry, skills and agents pile up with no record of what each one is for or whether it is still in use.
Example: A registry that lists your “Weekly Client Status Report” workflow, links it to the client delivery process, names the skill and MCP connections it uses, and marks it as running every Monday.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Markdown files in a working folder or Git repo, read and maintained by the Claude app or Claude Code |
| OpenAI (ChatGPT) | Markdown files in a working folder or Git repo, read and maintained by ChatGPT or Codex |
| Gemini | Markdown files in a working folder or Git repo, read and maintained by Gemini or Gemini CLI |
| M365 Copilot | Markdown files in a working folder, SharePoint, or Git repo, read by M365 Copilot |
A registry is platform-agnostic by design: it records the workflows you run on every platform. Set one up with the AI Registry setup guide.
Relationship to other blocks: The registry catalogs the other blocks — every skill, agent, and connection a workflow uses. Observability and evaluation results are most useful when they are tied back to a workflow’s registry record.
Observability
Section titled “Observability”Being able to see what an AI system is doing, why, and how well. Observability has three parts: metrics (the numbers over time, such as cost per run or error rate), traces (the step-by-step record of one run), and logs (the detailed record of each event, including what the AI was given and what it produced).
Key characteristics:
- Metrics show trends across many runs: cost, speed, error rate, how often a workflow runs
- Traces show one run step by step: which tools were called, in what order, and with what result
- Logs keep the detail: the exact inputs and outputs, so you can see why a run went the way it did
When to use it: When a workflow runs without you watching it: on a schedule, as an agent, or for other people. You cannot fix or trust what you cannot see.
Example: An agent that drafts the weekly client report starts producing thin summaries. The trace shows it stopped calling the project management connector after an authentication change, so it was writing from last week’s data.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Usage and logs in the Claude Console; OpenTelemetry metrics and events from Claude Code |
| OpenAI (ChatGPT) | Usage dashboard; built-in tracing in the Agents SDK |
| Gemini | Google Cloud Logging, Monitoring, and Trace for agents on Vertex AI |
| M365 Copilot | Copilot usage reporting in the Microsoft 365 admin center; analytics in Copilot Studio |
Relationship to other blocks: Observability watches agents, skills, and connections while they run. It supplies the evidence evaluation needs, and it is how you find out whether a problem sits in the model, the context, or the harness.
Evaluation
Section titled “Evaluation”Measuring, repeatably, whether the AI’s output is accurate, safe, and good enough: before you rely on it, after every change, and while it runs. AI output can vary from run to run and can get worse without anyone noticing, which is why evaluation is a block of its own.
Key characteristics:
- Repeatable: the same test cases or criteria, run the same way each time, so results can be compared
- Uses three kinds of grader: test cases you check against, an AI acting as a grader, or a person reviewing a sample of real runs
- Runs at three moments: before you rely on a workflow, after every change to it, and periodically while it runs
When to use it: Before you hand a workflow to others or let it run on its own, and every time you change its prompt, skill, model, or connections.
Example: Before switching the weekly report skill to a faster model, you rerun it on five past weeks of inputs and check each output against the same yes/no criteria: correct figures, every deliverable covered, the client’s preferred format.
Cross-platform implementations:
| Platform | How It Works |
|---|---|
| Claude | Evaluation tool in the Claude Console; test cases run through the API |
| OpenAI (ChatGPT) | Evals in the OpenAI platform; graders for model and agent output |
| Gemini | Gen AI evaluation service on Vertex AI |
| M365 Copilot | Agent evaluation and testing in Copilot Studio |
The AI Workflow Framework builds evaluation in: Test grades a workflow against yes/no criteria, and Improve reruns the same inputs to see what changed.
Relationship to other blocks: Evaluation checks the output of prompts, skills, and agents. It tells you when a model change or a skill edit made things better or worse, and it relies on observability for the evidence from real runs.
How the Blocks Fit Together
Section titled “How the Blocks Fit Together”The building blocks are composable — combine the ones your workflow needs. Here’s how a typical workflow grows as you adopt more blocks:
- Choose a Model — Select the right AI engine for your task (speed vs. depth, modality, cost)
- Start with a Prompt — Write clear instructions for what you want done
- Add Context — Attach reference materials so the model has what it needs
- Organize in a Project — Group your prompt and context so they persist across conversations
- Build Memory — Let the AI accumulate preferences, patterns, and knowledge across conversations
- Package as a Skill — Turn the prompt + context into a reusable routine you can invoke with different inputs
- Connect with MCP — Give the skill access to external data and tools
- Orchestrate with an Agent — Let an autonomous AI run the skill, use MCP connections, and handle multi-step workflows
- Interact via CLI — Use a terminal-native AI tool to work with code, automate tasks, and run headless AI jobs from the command line
- Call via API — Integrate the workflow into an application or automated pipeline by calling the model programmatically
- Build with an SDK — Use a framework to orchestrate agents, manage tool use, and coordinate multi-agent pipelines in code
- Record it in a Registry — Catalog the workflow, the process it serves, and the blocks it uses, so you always know what you have
- Evaluate and observe it — Check its output against repeatable criteria before you rely on it, and watch its runs once it works on its own
Every agent in these steps runs inside a harness: the app or tool around the model that supplies its tools, memory, and loop.
Worked example: Weekly Client Status Report
Section titled “Worked example: Weekly Client Status Report”| Stage | What Changes |
|---|---|
| Prompt only | You paste “Write a status report for Client X covering this week’s deliverables…” into a chat every Monday |
| + Context | You attach the client’s project brief and last week’s report so the model has history |
| + Project | You create a “Client Reports” project with the brief, templates, and standing instructions pre-loaded |
| + Memory | The project remembers your preferred report format, the client’s communication preferences, and that last week’s deliverable was delayed — no need to re-explain |
| + Skill | You package “generate weekly status report” as a skill — now you just invoke it with this week’s updates |
| + MCP | The skill pulls this week’s completed tasks from your project management tool and time entries from your time tracker |
| + Agent | An agent runs every Monday: gathers data via MCP, generates the report using the skill, drafts an email, and flags anything that needs your review |
| + CLI | You use a terminal-native AI tool to run the report workflow from the command line — interactively while refining, or headless on a schedule via cron |
| + API | You call the model via API from a script that runs on a schedule, processing inputs from a database and writing results back — no chat window needed |
| + SDK | You build the agent using a framework that handles tool orchestration, error recovery, and handoffs between a data-gathering agent and a report-writing agent |
| + Registry | You record the workflow in your registry: what it does, the client delivery process it serves, the skill and connections it uses, and that it runs every Monday |
| + Evaluation | Before relying on it, you rerun the skill on past weeks and check each report against the same yes/no criteria; you rerun the check after every change |
| + Observability | You review each Monday run’s trace, so when a report comes out thin you can see which step or connection failed |
Not every workflow needs every block. Many tasks are handled perfectly well with a prompt and some context. The blocks are a menu, not a checklist — use what the workflow actually requires.
Platform Comparison
Section titled “Platform Comparison”All building blocks across all four platforms in one view:
| Building Block | Claude | OpenAI (ChatGPT) | Gemini | M365 Copilot |
|---|---|---|---|---|
| Model | Multiple tiers (fast, balanced, reasoning) | Multiple tiers (fast, balanced, reasoning) | Multiple tiers (fast, balanced) | Microsoft-managed |
| Prompt | Conversation messages, system prompts | Conversation messages, system prompts | Conversation messages | Chat messages |
| Context | File attachments, project knowledge | File uploads, Workspace Agent files | File uploads, Drive, NotebookLM | Microsoft Graph, documents |
| Project | Claude Projects | ChatGPT Projects, Workspace Agents | Gems, Gemini Enterprise agents | Copilot agents |
| Memory | Claude memory, CLAUDE.md | ChatGPT Memory | Conversation memory | Microsoft Graph |
| Skill | Claude Code Skills, Claude.ai skills | Skills in ChatGPT, Workspace Agents, and Codex CLI | Gemini CLI skills | Not yet available |
| Agent | Claude Code agents, Cowork | Workspace Agents, Assistants API | Gemini Enterprise Agent Designer, ADK on Vertex AI | Copilot agents with plugins |
| Harness | The Claude app, Claude Code | ChatGPT, Codex | Gemini app, Gemini CLI | M365 Copilot, GitHub Copilot |
| MCP | MCP servers | Function calling, connectors in Workspace Agents | Extensions, function calling | Connectors, plugins |
| API | Anthropic REST API (Python, TypeScript SDKs) | OpenAI REST API (Python, TypeScript SDKs) | Gemini API, Vertex AI (Python SDK) | Azure AI Services (.NET, Python, Java) |
| SDK | Claude Agent SDK (Python, TypeScript) | OpenAI Agents SDK (Python, TypeScript) | Agent Development Kit (Python) | M365 Agents SDK (.NET, Python, TypeScript) |
| CLI | Claude Code | Codex CLI | Gemini CLI | GitHub Copilot CLI |
| Registry | Markdown files you own | Markdown files you own | Markdown files you own | Markdown files you own |
| Observability | Claude Console logs, Claude Code OpenTelemetry | Usage dashboard, Agents SDK tracing | Cloud Logging and Trace on Vertex AI | Microsoft 365 admin center reports, Copilot Studio analytics |
| Evaluation | Claude Console evaluation tool | OpenAI Evals | Vertex AI Gen AI evaluation service | Copilot Studio agent evaluation |
Common Misconceptions
Section titled “Common Misconceptions”“Skills and agents are the same thing.” Skills are routines — they do one specific thing when invoked. Agents are autonomous — they decide what to do, plan steps, and invoke skills (among other tools) to accomplish goals. A skill is a tool; an agent is the one using the toolbox.
“You need all blocks for every workflow.” Most workflows need two or three blocks. A well-written prompt with good context handles many tasks. Only add blocks when the workflow genuinely requires them.
“APIs and SDKs are the same thing.” An API is a raw interface — you send a request, you get a response. An SDK is a framework that builds on APIs, adding patterns for orchestration, tool use, memory, and multi-agent coordination. You can use APIs without an SDK, but SDKs make complex workflows much easier to build.
“Memory and context are the same thing.” Context is knowledge you provide — files, docs, examples attached to a conversation. Memory is knowledge the AI accumulates — preferences, past decisions, and patterns learned over time. You curate context; the AI manages memory.
“An agent is just a model.” An agent is a model plus a harness: the software that gives it tools, memory, and a loop to keep working. The same model behaves differently in different harnesses, and when an agent fails, the cause is often the harness rather than the model.
“Governance can wait until later.” A registry, observability, and evaluation are cheapest to add while a workflow is small. Once several workflows run on their own, you cannot easily tell what exists, what each one did, or whether a change made it worse.
“A project is just a folder.” A project is an active workspace — it provides standing instructions, persistent context, and conversation continuity. It shapes how the AI behaves for every conversation within it, not just where files are stored.
Related
Section titled “Related”Comparison and decision guide:
- Choosing the Right Building Block — comparison matrix and “I want to…” decision guide
Framework and courses:
- AI Workflow Framework — applies building blocks to workflow analysis
- Design Your AI Workflow — mapping workflow steps to building blocks
- Hands-on Agentic AI for Leaders — course covering AI strategy and building blocks
- Agentic AI for Claude Builders — hands-on course building with these blocks
Fundamentals deep-dives:
- Model — the AI engine that powers everything
- Prompts — the Prompt building block, with prompt engineering techniques
- Context — background information and reference materials
- Projects — project workspaces with memory, knowledge bases, and custom instructions
- Memory — accumulated knowledge from past interactions
- Skills — reusable routines the AI invokes when relevant
- Agents — concepts for the Agent building block
- MCP — connecting AI to external systems
- API — programmatic interfaces for accessing AI models and services
- SDK — frameworks and toolkits for building AI workflows in code
- CLI — terminal-native interfaces for interacting with AI
- AI Registry setup — set up the Registry block for your own workflows
- Test and Improve — the framework steps where Evaluation happens
- AI Engineering — practices for designing and optimizing AI systems, including context engineering
- Patterns — reusable approaches across building blocks
Use cases:
- AI Use Cases — what teams build with these blocks, organized by six primitives
Platform-specific guides:
- Claude Projects — setting up the Project block on Claude
- Claude Subagents — scheduling Agents on Claude