AI curriculum

Course outline for Agent Interoperability and Protocols

Learn which interfaces connect agents to tools, other agents, coding clients, user interfaces, and websites. Build a small MCP interaction and examine each other mechanism through its own concrete example and guided activity. Compare execution, context, identity, payment, and ecosystem governance without treating them as interchangeable protocols.

Agent Interoperability and Protocols Course Objectives

  • Select interfaces by their participants, responsibilities, and integration needs.
  • Extend and run a small MCP client/server interaction.
  • Explain A2A task exchange and ACP coding-client sessions through concrete messages.
  • Distinguish Agent Skills packaging from AG-UI interface events.
  • Compare WebMCP page tools with NLWeb natural-language website access.
  • Explain x402 payment roles and AAIF's ecosystem role separately.
  • Check compatibility, authorization, support status, and simpler alternatives.

Pre-requisites

  • Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.
  • Read JSON, use an API, and run a small client/server program.
  • No prior MCP implementation or expertise in the other interfaces is required.
  • Harness Engineering helps with Agent Skills; a self-contained format refresher is included.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.
  • Read JSON, use an API, and run a small client/server program.
  • No prior MCP implementation or expertise in the other interfaces is required.
  • Harness Engineering helps with Agent Skills; a self-contained format refresher is included.

Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.

Find your place in the learning map

Lab Setup

Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Preconfigured stable compatible MCP SDK/client/host, authorized model access, synthetic lookup data, tests, and message capture. Provide version-labeled A2A/ACP message examples, skill validation, an AG-UI replay, WebMCP/NLWeb examples, and an x402 payment simulation. No real wallet, payment, production federation, or preview browser is required. Verify the exact protocol/client pair before delivery; current documentation alone does not prove implementation support.

Detailed Course Outline

Module 1: MCP: connect an application to tools and context (2 hours)

  • MCP participants: Host, client, server, tools, resources, and prompts.
  • MCP transports: Local STDIO and remote Streamable HTTP responsibilities.
  • Capability and invocation contracts: Version/capability discovery, typed arguments, invocation, results, and errors.
  • MCP implementation: A minimal SDK server extension and actual client/host invocation.
  • Resources and prompts: Resource/prompt access through a supporting client.
  • Direct API and authority: Direct API comparison, trust, authentication, and action authorization.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Invoke the learner-extended MCP tool and distinguish an incompatible request from a denied action.

Module 2: A2A and ACP: agents and coding-client sessions (2 hours)

  • Agent discovery: Agent discovery, capability descriptions, task requests, status, and artifacts.
  • Task lifecycle: Task ownership, correlation, progress, cancellation, and errors.
  • Agent-service boundaries: Agent-service exchange versus tool invocation or internal subagent calls.
  • ACP (Agent Client Protocol): One hour on coding-client sessions, permissions, messages, and implementation limits.
  • Coding-client sessions: Editor/client and coding-agent roles, sessions, and capability negotiation.
  • Prompts and activity updates: Prompt requests, streamed updates, file/tool activity, and permission requests.
  • Transport and support limits: Local transport, remote-support limits, and comparison with MCP/A2A.
  • A2A — 1 hour
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Trace one concrete exchange per interface and specify who owns execution and session state.

Module 3: Agent Skills and AG-UI: reusable knowledge and interaction (2 hours)

  • Skill package: SKILL.md metadata, instructions, scripts, references, and assets.
  • Skill loading: Discovery, activation, progressive disclosure, and portability limits.
  • Skill and permission boundaries: A small conforming skill versus a tool interface or permission control.
  • Frontend/backend events: Frontend/backend roles, run events, messages, and state updates.
  • Human input and completion: Tool activity, human input, cancellation, and observed completion.
  • Events and authority: Event-stream interpretation versus rendered UI and backend authority.
  • Agent Skills — 1 hour
  • AG-UI — 1 hour
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Validate a small skill package and inspect/replay an interface-event example without conflating their roles.

Module 4: WebMCP and NLWeb: two routes into websites (2 hours)

  • Page tools: Page-exposed tools, descriptions, input schemas, and browser mediation.
  • Page and session authority: Page/session authority, user participation, and backend differences.
  • Browser support: Draft specification, actual browser/client support, and a sourced example.
  • Website queries: Natural-language website queries and structured content/results.
  • Structured query results: Query endpoints, Schema.org-based results, and MCP integration roles.
  • Sources and mutation limits: Query/result interpretation, source freshness, and unsupported mutation assumptions.
  • WebMCP — 1 hour
  • NLWeb — 1 hour
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Map both interfaces onto one website scenario and explain why their capability and support claims differ.

Module 5: x402, AAIF, and integration choices (2 hours)

  • Payment participants: HTTP 402 requirements and client, server, and facilitator roles.
  • Payment lifecycle: Payment payload, verification, settlement, response, and failure.
  • Spending and duplication: Spending authority, duplicate requests, and a simulated payment exchange.
  • Foundation governance: Foundation governance and project stewardship versus wire protocols.
  • Maturity and version boundaries: Specification, implementation, client support, maturity, and version boundaries.
  • Integration choice: Combine complementary interfaces and compare a simpler direct API.
  • x402 — 1 hour
  • AAIF and ecosystem integration — 1 hour
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Explain a simulated payment flow and justify an integration stack with explicit support and authority boundaries.

Practical exercise

  • Extend one narrow product-availability tool in a prepared MCP server. Connect a real client, capture discovery/invocation, and check the underlying lookup independently. Run one actual model-selected call through a prepared host. Use supporting client operations for a resource and prompt. Test an invalid or unsupported request and a separately unauthorized action. Keep this lab small enough for the two-hour MCP module; SDK/host setup is preflighted.
  • Each later one-hour topic has its own worked example and guided task, not just a row in a comparison table. Annotate A2A task ownership and ACP session updates. Validate a small skill package. Replay an AG-UI event stream and identify a false completion inference. Compare WebMCP tool exposure and NLWeb query/results for a synthetic website. Trace x402 with simulated payment evidence only. Finish with an interface-selection record and a direct-API alternative.

Delivery and timing

  • Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.

What you will produce

Run an MCP integration and select other agent interfaces using their actual participants, responsibilities, and limits.

How the work is checked

  • Actual MCP client/server/host execution returns independently checked data.
  • Compatibility and permission failures have distinct observed causes.
  • Each interface receives a separate example, learner task, and explanation.
  • A2A, ACP, Agent Skills, and AG-UI have distinct participants and responsibilities.
  • WebMCP draft/support limits are not inferred from ordinary MCP support.
  • NLWeb query access is not mistaken for arbitrary application mutation.
  • Payment evidence is not mistaken for blanket authority or task completion.
  • AAIF is correctly identified as an organization rather than a protocol.
  • The final selection cites sources, versions/support assumptions, and a simpler alternative.

10 guided hours. MCP receives two hours. A2A, ACP, Agent Skills, AG-UI, WebMCP, NLWeb, and x402 each receive one hour; AAIF and integration choice share one hour. Only the MCP path is a required full client/server implementation. Other mechanisms use explicitly labeled message, package, event, browser, or payment exercises. Availability, maturity, authorization, and conformance remain distinct; simulated payment spends no money.

When another approach is better

  • Use a direct API or local script when discovery and cross-client interoperability do not justify an extra protocol layer.
  • Do not deploy an integration based on schema conformance alone when identity, authority, and retry behavior are unresolved.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals