AI curriculum

Course outline for Agent Interoperability and Protocols

Agent integrations can expose similar-looking capabilities while assigning discovery, execution, identity, and payment to different layers. Compare version-labeled interface examples and design one local integration contract. Test compatibility and authority separately without assuming every named specification has the same maturity or purpose.

Technology: Agentic Systems
Duration: 4 hours
Modules: 2 · 2 hours each
Level: Level 3

About Agent Interoperability and Protocols

Agent Interoperability and Protocols Course Objectives

Distinguish tool access, agent coordination, procedural skills, and user-interface roles.
Inspect supplied discovery and invocation messages with explicit execution ownership.
Compare a direct API with a mock protocol-mediated capability.
Define versioned schemas, correlation IDs, permitted transitions, and retry behavior.
Reject incompatible and unauthorized mock requests independently.
Document support and maturity limits, distinguishing ecosystem organizations from wire protocols.

Pre-requisites

Applied Generative AI and Agentic AI Foundations, or equivalent typed model/tool interaction and agent-role competence.
Familiarity with APIs, JSON, and agent tool calls.
Basic programming or technical integration experience.

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

AI Security Foundations

Understands typed model/tool interactions and agent responsibilities; API/JSON and integration skills remain entry requirements.

Find your place in the learning map

Lab Setup

Computer with a JSON editor, programming runtime, and local mock HTTP service or supplied validator.
Version-labeled specification excerpts, discovery/invocation messages, dummy identities, and simulated payment artifacts.
No live federated agents, payment account, real transaction, or comprehensive multi-protocol implementation is required.

Detailed Course Outline

Module 1: Compare interface responsibilities (2 hours)

MCP: Tools, resources, prompts, discovery, and invocation; compare mock capability access with a direct API while retaining authentication and authorization responsibilities.
A2A: Agent discovery and task exchange in supplied messages; compare coordination responsibilities, correlation, and ownership with tool invocation under a verified version.
ACP (Agent Client Protocol): Editor-to-coding-agent communication over JSON-RPC/stdio; inspect version/capability negotiation, sessions, streamed updates, and permission requests. Distinguish editor integration from MCP tool access and A2A agent coordination; treat remote transport proposals as draft.
Agent Skills: Procedural instructions, discoverability, and reusable task knowledge; distinguish generic skill text from specification conformance and executable tool capabilities.
AG-UI: Agent-to-interface interaction roles in supplied artifacts; compare progress representation and user interaction with backend task execution and authority.

Practical outcome: Inspect version-labeled examples, separate MCP tools/resources/prompts from agent-task exchange, editor-agent sessions, and procedural skills, and compare a direct API with a mock invocation using schema, ownership, and identity questions.

Module 2: Design bounded web and ecosystem integration (2 hours)

WebMCP: Web-exposed capability descriptions in version-labeled examples; compare browser-facing integration assumptions with direct APIs without presuming universal client support.
NLWeb: Natural-language access to web content in supplied examples; compare discovery and query roles without equating them with authorized application mutations.
AAIF: Ecosystem stewardship and specification context; distinguish an organization from a wire protocol and record which interoperability claims remain unverified.
x402: Simulated payment-related request artifacts, correlation, and duplicate behavior; compare authorization and response contracts without conducting payments or claiming universal support.

Practical outcome: Compare supplied web-interface and simulated payment artifacts, identify AAIF as an ecosystem organization rather than a wire protocol, and define version/correlation, state, authority, and duplicate-request rules without assuming universal support.

Practical exercise

Produce a role/comparison matrix, one local integration contract, mock messages, and a validation report.
Accept a compatible permitted read request; reject a schema-version mismatch, invalid transition, and unauthorized mutation through separate checks.
Run at least six message fixtures, including a repeated request, and verify the contract's stated duplicate behavior and response correlation.
Record verified specification versions and unresolved interoperability assumptions; compare the contract with a simpler direct API without conducting a real payment.

What you will produce

Specify and test one bounded agent integration contract while distinguishing compatibility, execution ownership, and authorization.

How the work is checked

The comparison assigns distinct roles to the named interfaces and ecosystem organization.
Version and transition mismatches fail independently of identity/permission checks.
Repeated requests follow documented behavior and preserve correlation.
The selection records verified versions, support limits, and a direct-API alternative.

Four hours comparing version-labeled interfaces and testing one supplied mock contract within module time. Teach discovery, invocation, correlation, and authorization concretely; additional named interfaces receive role/maturity comparisons, not full implementations. Generic skill instructions do not prove formal Agent Skills conformance. No live payment or protocol-conformance certification is promised.

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

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