Author: Fabian Williams Date: November 2025 Project: ConferenceHaven - AI-powered conference session discovery
If at any point you have feedback, disagree with my positions, want to call me out, or eduate me... please start a discusison with me.. I (we) are all here hopefully to learn something new.. https://github.com/fabianwilliams/ConferenceHaven-Community/discussions
What if you could ask any AI assistant - Claude, ChatGPT, Copilot, or your local LLM - to find conference sessions for you? No searching through massive conference websites. No manually comparing schedules. Just ask.
That's ConferenceHaven.
Live Today:
- conferencehaven.com/chat - Web chat
- mcp.conferencehaven.com/api/mcp - MCP integration for AI clients
- a2a.conferencehaven.com - A2A demo with two collaborating LLMs
This document shares what I learned building ConferenceHaven - the wins, the challenges, and the opportunities I discovered. My hope is that sharing this journey helps others and contributes to making AI agent development more accessible.
┌─────────────────────────────────────────────────────────────────────────────┐
│ ConferenceHaven - November 2025 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ THREE WAYS TO ACCESS: │
│ │
│ 1. WEB CHAT - Just open your browser │
│ conferencehaven.com/chat │
│ │
│ 2. MCP TOOLS - Add to Claude Desktop, ChatGPT, LM Studio, Copilot Studio, │
│ Agent Toolkit, URL: https://mcp.conferencehaven.com/api/mcp │
│ │
│ 3. A2A AGENTS - Two LLMs collaborating intelligently │
│ Demo: https://a2a.conferencehaven.com │
│ │
│ DATA: 4 conferences, 2,060+ sessions │
│ • Microsoft Ignite 2025 (1,545 sessions) │
│ • Live360 Orlando 2025 (196 sessions) │
│ • TechCon365 Dallas 2025 (174 sessions) │
│ • ESPC25 Dublin 2025 (145 sessions) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
My first goal was simple: let any AI client search conference sessions via the Model Context Protocol (MCP).
What MCP Does Well:
- Standardized way for AI clients to call tools
- Works with Claude Desktop, LM Studio, VS Code, Copilot Studio, Agent Toolkit, and more
- Clear tool definitions with JSON schemas
The Challenge I Hit: The documentation focused on local (stdio) transport. I needed HTTP for remote access - no one wants to install a local package just to search conferences.
The Solution: I used FastMCP directly (not through Agent Framework) to create an HTTP endpoint:
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("conferencehaven", stateless_http=True)
@mcp.tool()
def search_sessions(query: str, conference: str = None):
"""Search conference sessions by topic, speaker, or keyword."""
# ... implementationResult: https://mcp.conferencehaven.com/api/mcp - works with any MCP-compatible client!
After getting MCP working, I noodled a bit in my head and realized that there is another protocol designed specifically for the purpose I needed which is complimentary: A2A (Agent-to-Agent).
According to the A2A Protocol specification, these protocols are complementary, not competing:
- MCP (Model Context Protocol): Focuses on "agent-to-tool communication" - how agents connect to tools, APIs, and resources
- A2A Protocol: Enables "agent-to-agent communication" - a universal standard allowing AI agents to collaborate across different frameworks
Source: A2A Protocol Documentation
The Key Insight:
In the diagram above, notice how each Agent has its own LLM and uses MCP to connect to its tools. The A2A protocol sits between agents, enabling them to delegate tasks across organizational or technological boundaries.
| Protocol | Purpose | When to Use |
|---|---|---|
| MCP | Agent-to-Tool | Connecting an agent to external tools and data sources |
| A2A | Agent-to-Agent | Orchestrating multiple agents that need to delegate tasks and coordinate |
Why This Matters for ConferenceHaven:
| Question | MCP Response | A2A Response |
|---|---|---|
| "What is ESPC about?" | Tool doesn't know | Host Agent answers from knowledge |
| "Find AI sessions" | Returns raw data | Remote Agent searches, filters, formats intelligently |
| "AWS re:Invent sessions" | Error: not in database | Host Agent explains it's not supported yet |
With A2A, the remote agent exercises judgment. It can answer questions the tools can't handle because it has its own LLM making decisions.
I wanted to implement A2A for ConferenceHaven. When I looked at the Microsoft Agent Framework documentation, I found this:
From the Microsoft Learn documentation on A2A Integration:
"This tutorial describes A2A integration in .NET apps; Python integration is in the works."
The .NET implementation looked exactly like what I needed - MapA2A() for exposing agents over HTTP with agent card discovery. But I already made a choice to do all this in Python because Microsoft Agent Framework is for feature rich in Python or so I assumed :-) in the end I ended up with building on FastAPI.
Rather than wait, I built it myself using the A2A Protocol specification as my guide.
The Two-LLM Architecture:
┌─────────────────────────────────────────────────────────────────────────────┐
│ A2A: Two LLMs Collaborating │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────┐ ┌─────────────────────────────────┐ │
│ │ HOST AGENT │ │ CONFERENCEHAVEN AGENT │ │
│ │ (Azure OpenAI) │ │ (OpenAI) │ │
│ │ │ │ │ │
│ │ "Should I delegate │ A2A │ "How should I search and │ │
│ │ this question?" │ ──────> │ format this response?" │ │
│ │ │ │ │ │
│ │ DECIDES: IF │ │ DECIDES: HOW │ │
│ └─────────────────────────┘ └─────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
What This Enables:
The Host Agent at a2a.conferencehaven.com can:
- Answer general questions ("What is ESPC?") from its knowledge
- Delegate specific queries ("Find AI sessions") to ConferenceHaven
- Gracefully handle unsupported requests ("AWS re:Invent sessions")
Try it yourself: Visit a2a.conferencehaven.com
- FastMCP for HTTP endpoints - Clean, simple, works with every MCP client
- Agent Card discovery -
/.well-known/agent.jsonis an elegant pattern for agent discovery - Two LLMs > One LLM - The Host Agent adds judgment that tools alone can't provide
- Multiple access patterns - Different users need different entry points (web, MCP, A2A)
These aren't complaints - they're opportunities I'd love to see the community address:
- A2A Python SDK - I built A2A manually; an official SDK would make this easier for everyone
- MCP HTTP documentation - More examples of remote MCP deployment would help
- Agent observability - Production tracing for multi-agent systems is an emerging need
- Start with the user experience - Web chat first, then expand to MCP and A2A
- Don't fight local-only tooling - If something is designed for local dev, use proper production alternatives
- Two protocols are better than one - MCP for tools, A2A for agents - they complement each other
- Build the demo - Nothing clarifies thinking like a working implementation
For those interested in the implementation:
| Component | Technology | Purpose |
|---|---|---|
| MCP Server | FastMCP + FastAPI | Tool access for AI clients |
| Web Chat | Microsoft Agent Framework | Browser-based chat |
| A2A Server | Custom Python + FastAPI | Agent-to-agent protocol |
| Host Agent | Azure OpenAI + Gradio | A2A demo interface |
| Database | Azure SQL | Session storage |
| Analytics | FastAPI + React + Auth0 | Usage insights |
| Observability | OpenTelemetry + Aspire | Production monitoring |
Just visit conferencehaven.com/chat
Add to your AI client's MCP settings:
{
"mcpServers": {
"conferencehaven": {
"url": "https://mcp.conferencehaven.com/api/mcp"
}
}
}Discover the agent:
curl https://agent-chat.agreeablehill-3054e8bb.eastus2.azurecontainerapps.io/.well-known/agent.jsonSend a message:
curl -X POST https://agent-chat.agreeablehill-3054e8bb.eastus2.azurecontainerapps.io/a2a/message:send \
-H "Content-Type: application/json" \
-d '{
"message": {
"message_id": "test-1",
"role": "user",
"parts": [{"kind": "text", "text": "Find AI sessions at ESPC"}]
}
}'The AI agent ecosystem is evolving rapidly. Here's what I'm excited about:
- More conferences - Expanding to additional tech conferences
- Smarter recommendations - Using session history to suggest relevant talks
- Deeper A2A integration - Multi-agent workflows for conference planning
- Community contributions - Your feedback shapes the roadmap!
- Try it: conferencehaven.com/chat
- Integrate it: Add the MCP server to your AI workflow
- Give feedback: Open an issue
- Connect: conferencehaven@adotob.com
These resources shaped my understanding and implementation:
- A2A Protocol Specification - The official A2A standard
- How A2A Works with MCP - Complementary protocols explained
- Model Context Protocol - MCP specification
- A2A Integration Guide (.NET) - Where I learned Python support was "in the works"
- Can You Build Agent2Agent on MCP? - Great framing of the challenges
- ConferenceHaven A2A Demo - Try the two-LLM collaboration
- A2A Integration Guide - Technical details for developers
This project stands on the shoulders of giants:
- Microsoft Agent Framework team - For ChatAgent and the vision
- Anthropic - For MCP and Claude
- Google - For the A2A protocol specification
- The conference organizers - For making session data available
- The community - For feedback and encouragement
Building the future of conference discovery, one agent at a time.
Fabian Williams November 2025