AzureFeeds

The world of AI agents is evolving rapidly, with new protocols and frameworks emerging to enable sophisticated multi-agent communication. Google’s Agent-to-Agent (A2A) protocol represents one of the most promising approaches for building distributed AI systems that can coordinate tasks across different platforms and services.

I’m excited to share how you can leverage Azure App Service to build, deploy, and scale A2A applications. Today, I’ll walk you through a practical example that combines Microsoft Semantic Kernel with the A2A protocol to create an intelligent travel planning assistant.

What We Built: An A2A Travel Agent on App Service

I’ve taken an existing A2A travel planning sample and enhanced it to run seamlessly on Azure App Service. This demonstrates how A2A concepts can be adapted and hosted on one of Azure’s platform-as-a-service offerings. What started as a sample implementation has been transformed into a full-featured web application with a modern interface, real-time streaming, and production-ready deployment automation.

Acknowledgments and Attribution

Before diving into the technical details, I want to give proper credit where it’s due. This application was adapted and enhanced from excellent foundational work by the Microsoft Semantic Kernel team and the A2A project community:

• Original inspiration: Microsoft DevBlogs – Semantic Kernel A2A Integration


• Base implementation: A2A Samples – Semantic Kernel Python Agent

This contribution builds upon these samples to demonstrate how you can take A2A concepts and create a complete, deployable application that runs seamlessly on Azure App Service with enterprise-grade features like managed identity authentication, monitoring, and infrastructure as code.

Why A2A on Azure App Service?

Azure App Service provides the perfect foundation for A2A applications because it handles the infrastructure complexity while giving you the flexibility to implement cutting-edge AI protocols. Here’s what makes this combination powerful:

Understanding the A2A Travel Agent Architecture

Our sample demonstrates a multi-agent system where a main travel manager coordinates with specialized agents:

┌─────────────────────┐      ┌──────────────────────┐      ┌─────────────────────┐

│     Web Browser     │ ──── │    FastAPI App       │ ──── │  Semantic Kernel    │

│                     │      │                      │      │   Travel Agent      │

│ • Modern UI         │      │ • REST API           │      │                     │

│ • Chat Interface    │      │ • A2A Protocol       │      │ • Currency API      │

│ • Responsive        │      │ • Session Management │      │ • Activity Planning │

└─────────────────────┘      └──────────────────────┘      └─────────────────────┘

                                        │

                                        ▼

                             ┌──────────────────────┐

                             │    A2A Protocol      │

                             │                      │

                             │ • Agent Discovery    │

                             │ • Task Streaming     │

                             │ • Multi-Agent Coord  │

                             └──────────────────────┘

Key Components

1. TravelManagerAgent: The orchestrator that analyzes user requests and delegates to specialized agents


2. CurrencyExchangeAgent: Handles real-time currency conversion using the Frankfurter API


3. ActivityPlannerAgent: Creates personalized itineraries and activity recommendations


4. A2A Protocol Layer: Manages agent discovery, task coordination, and streaming responses

Practical Example: Multi-Agent Travel Planning

Let’s see this in action with a real user scenario:

Implementation Highlights

Modern Web Interface

The application includes a responsive web interface built with modern HTML/CSS/JavaScript that provides:

• Real-time chat with typing indicators


• Streaming responses for immediate feedback


• Mobile-responsive design


• Session management for conversation context

A2A Protocol Compliance

Full implementation of Google’s A2A specification including:

• Agent Discovery: Structured Agent Cards advertising capabilities


• Task Coordination: Multi-agent task delegation and handoffs


• Streaming Support: Real-time progress updates during complex workflows


• Session Management: Persistent conversation context

Azure-Native Features

• Managed Identity: Secure authentication without API key management


• Bicep Templates: Infrastructure as code for reproducible deployments


• Azure Developer CLI: One-command deployment with azd up

Getting Started: Deploy Your Own A2A Agent

Ready to try it yourself? Here’s how to deploy this A2A travel agent to Azure App Service:

Prerequisites

• Azure CLI and Azure Developer CLI (azd)


• Python 3.10+ for local development


• An Azure subscription

Deployment Steps

That’s it! The Azure Developer CLI will:

Beyond This Example: A2A Possibilities

While Semantic Kernel was chosen for this sample, we recognize that developers have many options for building A2A applications. The A2A protocol is framework-agnostic, and Azure App Service can host agents built with:

• LangChain for comprehensive LLM application development


• LlamaIndex for data-augmented agent workflows


• AutoGen for multi-agent conversation frameworks


• Custom implementations using OpenAI, Anthropic, or other AI APIs


• Any Python web framework (FastAPI, Django, Flask, etc.)


• And many more!

The key insight is that Azure App Service provides a robust, scalable platform that adapts to whatever AI framework or protocol you choose.

Why This Matters for the Future

The AI agent ecosystem is evolving rapidly. New protocols, frameworks, and integration patterns emerge regularly. What excites me most about Azure App Service in this context is our platform’s adaptability:

• 🔄Framework Flexibility: Host basically any AI framework or custom implementation


• 🌐Protocol Support: WebSocket, HTTP/2, and custom protocols for agent communication


• 🔐Security Evolution: Managed identity and certificate management that scales with new auth patterns


• 📈Performance Optimization: Auto-scaling and performance monitoring that adapts to AI workload patterns


• 🛠️DevOps Integration: CI/CD pipelines and deployment automation for rapid iteration

Looking Ahead

As A2A protocols mature and new agent frameworks emerge, Azure App Service will continue evolving to support the latest innovations in AI application development. Our goal is to provide a platform where you can focus on building intelligent agent experiences while we handle the infrastructure complexity.

We’re particularly excited about upcoming enhancements in:

• Integration with Azure AI services for even richer agent capabilities


• Streamlined deployment patterns for AI application architectures


• Improved monitoring and observability for multi-agent workflows

Try It Today

The A2A travel agent sample is available now on GitHub and ready for deployment. Whether you’re exploring multi-agent architectures, evaluating A2A protocols, or looking to modernize your AI applications, this sample provides a practical starting point.

🚀 Deploy the A2A Travel Agent

We’d love to hear about the A2A applications you’re building on Azure App Service. Share your experiences, challenges, and innovations with the community—together, we’re shaping the future of distributed AI systems.

Questions about this sample or Azure App Service for AI applications? Connect with us in the comments below.