Enterprise agents need more than intelligence. They need dependable ways to discover capabilities, access tools, retrieve resources and delegate work across organisational boundaries. Proprietary integrations can solve individual use cases, but they become difficult to govern and reuse as the number of models, agents and systems grows.
The Model Context Protocol (MCP) and Agent-to-Agent Protocol (A2A) address different parts of this problem. MCP standardises how an AI application connects to tools and contextual resources. A2A supports task-oriented communication and delegation between independent agents. Used together, they provide useful building blocks for interoperable agent platforms—but they do not remove the need for identity, policy and operational control.
This course teaches both protocols through implementation and architecture exercises. It also prepares participants for evolving specifications by concentrating on stable concepts, capability negotiation and disciplined lifecycle management.
Learning Outcomes
Upon completion of this course, participants will be able to:
- Explain the roles and boundaries of MCP and A2A
- Design an MCP server with clear tools, resources and authorisation
- Connect an agent to local and remote MCP capabilities
- Describe and discover agent capabilities using A2A Agent Cards
- Implement task delegation and status handling between agents
- Apply identity, least privilege and user-context propagation
- Instrument protocol interactions with audit logs and distributed tracing
- Govern interoperable tools and agents across an enterprise platform
Course Outline
The Interoperability Landscape
- Why agent integrations need shared protocols
- MCP for agent-to-tool and agent-to-resource connectivity
- A2A for agent discovery, delegation and collaboration
- Relationship to APIs, function calling and workflow engines
- Where custom integration remains appropriate
- Designing for multiple models, frameworks and cloud platforms
MCP Architecture and Core Concepts
- Hosts, clients, servers and capability discovery
- Tools, resources and reusable interaction patterns
- Local and remote server deployment
- Structured schemas and model-friendly tool descriptions
- Stateless protocol operation and explicit application state
- Managing protocol versions and deprecations
Building an MCP Server
- Designing small tools around business capabilities
- Defining validated inputs, outputs and useful errors
- Exposing controlled resources without leaking authority
- Separating read, propose and execute operations
- Testing with protocol inspectors and automated clients
- Packaging and deploying a reusable server
Remote MCP and Long-Running Work
- HTTP transport, routing and horizontal scaling
- Tasks, progress, cancellation and resumable operations
- Explicit handles for stateful business processes
- Timeouts, retries and idempotent tool actions
- Caching capability and resource metadata safely
- Propagating trace context across downstream services
MCP Authorization and Security
- Resource and authorisation server responsibilities
- OAuth 2.0 and OpenID Connect deployment patterns
- Scopes, step-up authorisation and short-lived credentials
- Binding agent actions to user permissions
- Defending against malicious servers and tool poisoning
- Auditing discovery, invocation and consequential side effects
A2A Concepts and Agent Discovery
- Agent Cards and capability advertisement
- Tasks, messages, artefacts and status updates
- Synchronous, streaming and asynchronous interaction patterns
- Opaque collaboration across implementation boundaries
- Authentication schemes and enterprise endpoints
- Matching tasks to trustworthy agent capabilities
Implementing Agent-to-Agent Delegation
- Creating a client agent and specialist remote agent
- Passing context without exposing unnecessary data
- Defining task ownership, deadlines and cancellation
- Handling partial results and requests for clarification
- Preventing uncontrolled delegation chains
- Combining A2A collaboration with MCP tool access
Enterprise Architecture Patterns
- Central registries for approved tools and agents
- Gateways, policy enforcement and traffic controls
- Cross-agent identity and delegated authority
- Network zoning and data-residency constraints
- Observability across protocol and service boundaries
- Avoiding duplicated capabilities and unmanaged agent sprawl
Governance and Lifecycle Management
- Reviewing and approving servers, tools and Agent Cards
- Versioning contracts without breaking consumers
- Vulnerability disclosure and dependency management
- Ownership, service levels and retirement procedures
- Continuous evaluation of connected capabilities
- Maintaining an inventory for security and compliance
Practical Capstone
- Build and secure a remote MCP server for an enterprise capability
- Publish an A2A specialist agent that uses the MCP server
- Delegate a long-running task from a client agent
- Propagate identity, trace context and task status
- Test failure, cancellation and unauthorized access
- Present the architecture and governance controls
Intended audience
This course is intended for software developers, AI engineers, integration specialists, platform engineers and solution architects connecting agents to enterprise systems or to one another. It is suitable for teams that already understand APIs and want a practical, protocol-accurate approach to agent interoperability.
Prerequisites
Those attending this course should meet the following:
- Proficiency in Python, TypeScript or another API development language
- Familiarity with HTTP, JSON and API integration
- Basic understanding of OAuth 2.0 and service authentication
- Introductory knowledge of AI agents and tool calling