Every Copilot Studio noun, mapped to the concept you already carry from building agents on opencode and wiring MCP by hand. Read left→right to translate; watch the false friends where the mapping lies.
Core agent
Copilot Studio's agent bundles model + instructions + knowledge + tools + topics + triggers into one object. (Older docs say "copilot" or "bot" — same thing.)
Plain-text box on the agent's Overview page. Type / to reference a tool, topic, variable, or Power Fx expression inline — that's how you wire behavior to components.
You can now pick the underlying model (including Claude Sonnet 4.5 / Opus 4.5), or pull a model from the Foundry model catalogue for custom prompts.
The big one. Two modes — generative vs classic. See the keystone at the bottom; don't skim it.
Tools & integration
Umbrella term — broader than function-calling. In Copilot Studio "tools" covers MCP tools, connectors, REST API tools, agent flows, and prompts. Anything the agent can invoke.
Same protocol you run today. Add it as a tool and point it at the server. Basically free points for you.
Three wrappers for the same idea. Custom connector = reusable, auth-managed definition. Send HTTP request = raw one-off. REST API tool = expose an endpoint to the agent.
Power Platform connectors (1000+ prebuilt to SaaS apps) and Copilot / Graph connectors (pull org content in as knowledge).
Agent takes actions in a UI on the user's behalf. Know when it's the right tool vs an API call — that's the exam angle.
Knowledge & retrieval
Attach docs/sites as knowledge; the generative answers node answers from them instead of the base model. It's RAG with a GUI.
The grown-up grounding backend for unstructured docs. Often surfaced via Foundry.
The structured-data counterpart to doc-RAG. Docs → Azure AI Search; analytical/semantic-model data → Fabric data agent; single live record → a connector.
Logic, state & data
A deterministic conversation path built from nodes. This is the un-LLM part — hardcoded flow for things that must be predictable. Optional trigger phrases fire it in classic mode.
Power Automate under the hood. Structured automation behind the chat — supports approvals, input/output params, error handling.
An approval step inside an agent flow. Person confirms before the flow proceeds.
Excel-formula-flavored, not a general language. Low ceiling — read it, write simple ones, don't expect Python.
Scope is tested: global = whole agent; topic = local to one conversation path.
Microsoft's managed data backend (tables/rows). Where agent + solution data lives.
JSON-defined UI cards for responses. Learn the JSON shape.
Multi-agent
Delegation within Copilot Studio. Your parent agent calls a specialized child.
Hand-off across platforms/vendors. The connected-vs-A2A line (same platform vs cross-platform) is a recurring exam question.
Bring a Foundry-hosted or already-built agent into your solution as a collaborator.
Deploy & operate
Teams, a website, M365 Copilot, custom — anything on Azure Bot Service.
A solution is the deployable package (managed vs unmanaged); environments isolate dev/test/prod.
Promote a solution dev→test→prod without manual rebuild.
So endpoints/keys aren't hardcoded across environments.
Telemetry for the deployed agent. Familiar concept, Azure branding.
Build cases, pick an eval method, review results. Domain 3 — the sleeper.
Connectors carry their own connection/auth. "Identity strategy" = the planning-level version (who authenticates, end-user vs agent).
Guardrails/moderation/groundedness + Data Loss Prevention for governance.
False friends — where the mapping lies
In your head a tool ≈ a function the model can call. In Copilot Studio tools also include connectors, agent flows, and even prompts. When a question says "add a tool," it may mean any of those — read the scenario.
Topics are scripted dialog paths, not callable functions. Closest analog is a hardcoded, deterministic conversation branch. If something must be predictable/compliant, it's a topic; if it's open-ended reasoning, that's the model + generative answers.
It does not mean your orchestration-framework sense. It's a binary setting on the agent: generative vs classic. Answering an "orchestration" question with framework intuition will burn you.
It looks like code but it's Excel-formula-flavored with a low ceiling. Don't reach for loops/classes — the exam expects you to read and write simple expressions, nothing more.
A topic is conversation (what the agent says). An agent flow is background automation (what the agent does — Power Automate). Questions test whether you reach for the right one.
Keystone concept — learn this cold
This is the one concept with no clean 1:1 in your world, and it shows up everywhere on the exam.
The agent decides at runtime which combination of topics, tools, and knowledge to use for a given request — driven by the names/descriptions you write for each. Flexible, LLM-planned.
≈ letting the model plan & routeThe user's message is matched to a topic's trigger phrases via NLU, and that topic's scripted path runs. Deterministic, author-controlled.
≈ intent-matching to hardcoded flows