Skip to content

Choosing the Right Building Block

Ten building blocks, three layers — but which ones does your workflow actually need? This page gives you comparison tables to quickly differentiate the blocks and a decision guide to match your situation to the right starting point.

Most workflows need just two or three blocks. The goal isn't to use all ten — it's to pick the right ones for the job.

Start simple

Begin with a Prompt and add blocks only when you hit a real limitation. If you're re-typing the same instructions, add a Skill. If you need external data, add MCP. If you need multi-step autonomy, add an Agent. Don't over-engineer — let the workflow tell you what it needs.

At a Glance

All ten blocks in one view — use this to quickly orient yourself, then drill into the layer tables below for full details.

Block Primary Job Best For Typical User
Model Process and generate Choosing the right engine for speed, depth, or cost Everyone
Context Inform Grounding the model in your specific domain knowledge Everyone
Project Organize Persisting instructions and context across conversations Everyone
Memory Remember Accumulating preferences and patterns over time Everyone
Prompt Instruct One-off or conversational tasks with clear instructions Everyone
Skill Standardize Repeatable routines you run the same way every time Everyone
Agent Execute autonomously Multi-step workflows requiring planning and tool use Power user
MCP Connect Bridging AI to external tools, data, and services Power user
API Integrate programmatically Embedding AI in applications and automated pipelines Developer
SDK Orchestrate in code Building agent systems with tool use, memory, and handoffs Developer

Intelligence Layer

The persistent foundation: engine, knowledge, and workspace powering every interaction.

Model Context Project Memory
What it provides AI engine that processes inputs and generates outputs Background knowledge the model doesn't have Persistent workspace grouping instructions, context, and skills Accumulated knowledge from past interactions
Primary job Process and generate Inform Organize Remember
Persistence Always available (platform-managed) Ephemeral (per-conversation) or attached to a project Persistent across conversations Persistent and growing across conversations
Contains Trained weights, capability tiers, modality support Files, docs, data, examples, reference material Instructions, context files, conversation history, skills Preferences, decisions, facts, learned patterns
When it loads Selected before or during a conversation Attached at conversation start or mid-conversation Active when you open a conversation in the project Retrieved automatically when relevant
Can include code No (model selection, not authoring) Yes (code files as reference material) Yes (code in project knowledge or instructions) No (system-managed, natural language)
Best for Choosing the right engine for speed, depth, or cost Grounding the model in your specific domain Persisting setup so you don't re-upload every time Adapting AI behavior over time without manual setup
Who manages it Platform (you choose tier) User-curated User-curated System-managed
Requires external access No No (you bring the files) No No
Typical user Everyone Everyone Everyone Everyone

Orchestration Layer

The execution layer: instructions, routines, and autonomous agents that direct and do the work.

Prompt Skill Agent
What it provides Natural language instructions to the model Reusable routine with defined inputs and outputs Autonomous AI that plans, uses tools, and executes multi-step work
Primary job Instruct Standardize Execute autonomously
Persistence Ephemeral (per-conversation) Persistent (saved as files, reusable across conversations) Ephemeral (runs for a session) or scheduled
Contains Natural language instructions, examples, constraints Instructions, reference files, output format specs Goals, tool access, planning logic, decision-making
When it loads When you type or send a message Auto-triggered when relevant, or invoked via slash command Launched explicitly or on a schedule
Can include code No (natural language only) Yes (scripts, templates, code references) Yes (reads, writes, and runs code)
Best for One-off or conversational tasks with clear instructions Repeatable routines you run the same way every time Multi-step workflows requiring planning and tool use
Who manages it User (typed in the moment) User-curated (packaged for reuse) User-launched or developer-built
Requires external access No No (self-contained instructions) Often yes (uses tools, files, MCP connections)
Typical user Everyone Everyone Power user

Integration Layer

The connection layer: protocols, interfaces, and frameworks that bridge AI to external systems and code.

MCP API SDK
What it provides Connector to external tools, services, and databases Programmatic interface for accessing AI models Frameworks for building AI workflows in code
Primary job Connect Integrate programmatically Orchestrate in code
Persistence Persistent (configured once, available across conversations) Stateless (each call is independent) Persistent (code you deploy and maintain)
Contains Server configs, tool definitions, authentication API keys, endpoint URLs, request/response schemas Libraries, agent loops, tool abstractions, patterns
When it loads Connected at startup or configured in settings Called on demand from code Imported into your application code
Can include code Yes (server implementations) Yes (code making HTTP requests) Yes (the primary interface is code)
Best for Bridging AI to external tools, data, and services Embedding AI in applications and automated pipelines Building agent systems with tool use, memory, and handoffs
Who manages it User-configured or developer-built Developer-owned Developer-owned
Requires external access Yes (bridges to external systems) Yes (calls external APIs) Yes (wraps APIs and external services)
Typical user Power user Developer Developer

Decision Guide: "I want to..."

Use this table to find your starting point. Most real workflows combine several blocks — this tells you where to begin.

I want to... Start with Add when needed
Ask AI a question Prompt + Context if it needs your specific data
Get better answers about my domain Context + Prompt + Project to persist the setup
Stop re-uploading the same files Project + Memory to also retain learned preferences
Have AI remember how I like things done Memory Already persistent — just keep using it
Run the same workflow every week Skill + MCP if the skill needs external data
Pull live data into a conversation MCP + Skill to standardize what you do with the data
Automate a multi-step research task Agent + MCP for external sources, + Skill for sub-routines
Build AI into my app API + SDK for complex orchestration
Coordinate multiple agents in code SDK + MCP for external tool access
Choose between fast and deep AI Model (select the right tier) All other blocks work with any model