Agentic AI Building Blocks¶

Platforms: claude openai gemini m365-copilot

Overview¶

The nine 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 nine pieces.

Model · Prompt · Context · Project · Skill · Agent · MCP · API · SDK

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 does it handle models, prompts, context, projects, skills, agents, external connections, APIs, and development frameworks?"

Summary¶

The Nine Building Blocks¶

Model¶

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:

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.

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:

Relationship to other blocks: Prompts are the foundation — context enhances them, skills package them for reuse, and agents chain them together.

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:

Relationship to other blocks: Context makes prompts smarter. Projects organize context persistently so you don't re-upload it every time.

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:

Relationship to other blocks: Projects are containers — they hold the prompts, context, and skills a workflow needs, making the whole package reusable.

Skill¶

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:

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.

Agent¶

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:

Relationship to other blocks: Agents orchestrate the other blocks — they use prompts, draw on context, invoke skills, and connect to external systems through MCP.

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:

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.

API¶

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:

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.

SDK¶

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:

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.

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:

1. Choose a Model — Select the right AI engine for your task (speed vs. depth, modality, cost)
2. Start with a Prompt — Write clear instructions for what you want done
3. Add Context — Attach reference materials so the model has what it needs
4. Organize in a Project — Group your prompt and context so they persist across conversations
5. Package as a Skill — Turn the prompt + context into a reusable routine you can invoke with different inputs
6. Connect with MCP — Give the skill access to external data and tools
7. Orchestrate with an Agent — Let an autonomous AI run the skill, use MCP connections, and handle multi-step workflows
8. Call via API — Integrate the workflow into an application or automated pipeline by calling the model programmatically
9. Build with an SDK — Use a framework to orchestrate agents, manage tool use, and coordinate multi-agent pipelines in code

Worked example: Weekly Client Status Report¶

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¶

All nine building blocks across all four platforms in one view:

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 nine 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.

"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¶

Framework and courses:

• Business-First AI Framework — applies building blocks to workflow analysis
• Design Your AI Workflow — mapping workflow steps to building blocks
• Agentic AI for Leaders — course covering AI strategy and building blocks
• Claude for 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
• 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
• 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 Skills — discovering Skills on Claude
• Claude Subagents — scheduling Agents on Claude