Building Multi-Agent Systems the A2A Way: A Hands-On Project with LangGraph

 A claims processing system with three services that communicate using Google's A2A (Agent-to-Agent) protocol over JSON-RPC 2.0:

🔹 A Gateway that handles auth, guardrails, and routing 🔹 A Claims Agent that validates claims and checks for fraud 🔹 A Policy Agent that answers coverage and benefits questions

Each agent publishes its own capabilities at a standard /.well-known/agent-card.json endpoint — meaning any A2A-compatible client can discover what it does without me hard-coding anything. Same pattern you'd use to plug into a partner agent in real production.

🛠️ The stack

✅ FastAPI + Pydantic for the JSON-RPC layer ✅ LangGraph for stateful agent reasoning (StateGraph + checkpointing) ✅ MCP (Model Context Protocol) for clean tool abstraction ✅ Anthropic Claude — using Haiku for routing, Sonnet for reasoning, Opus reserved for hard cases ✅ LangSmith for end-to-end observability ✅ Custom guardrails for PII detection and prompt injection

🔍 Why this combo clicks

Most agent tutorials show you a single agent calling some tools. That's fine for demos. But real systems need symmetric communication (any agent calling any other), discoverability (no hard-coded contracts), auditability (especially in regulated domains), and composability (swap an agent without rewriting the orchestrator).

A2A + JSON-RPC handles communication between agents. LangGraph handles reasoning inside each agent. Clean separation. Each piece does what it's good at.

📊 The LangSmith moment

This is where it got fun. Once I wired up tracing, every request became a fully visible tree — LangGraph nodes, every LLM call with token counts and latency, every tool invocation with full inputs and outputs.

A Look up claim CLM-1003 request showed up as a 16.39s trace: call_llm → claim_lookup tool → call_llm → final synthesis. I could literally watch the model reason.



💡 Three things that surprised me

JSON-RPC 2.0 is underrated. It's old, boring, and exactly what multi-agent systems need. No need to reinvent the wheel.

MCP makes tools portable. I wrote my tools once. Today they plug into Claude's tool-use API. Tomorrow they plug into any MCP server with zero code change.

Three-tier model routing is a massive cost lever. Haiku for routing, Sonnet for reasoning, Opus only when needed. Easily a 5–10× difference in spend.

🔗 Code is open

Full repo here — feel free to fork, break, learn from, or roast my design choices: 👉 https://github.com/sudeepkrishnan87/a2a-insurance-system


Comments

Post a Comment

Popular posts from this blog

SOLID Principle (Quick Read)

Image
 The famous design principle comprises 5 design strategies that a developer should follow for a successful application development Single Responsibility Principle Open/ Close Principle Liskov Substitution Principle Interface Segregation Principle Dependency Inversion Single Responsibility Principle(SRP) No code unit(function/class/package) should have more than one responsibility.   Bad Ex:   Class Bird  {     String result;;    public fly(Bird bird)    {     if(bird==piegeon)       result="flys 20 meter hight";    else if(bird==hen)       result="flys 5 meter";    else        result="not measured yet";    } } This class should design such a way that it should work well for all the types of birds current design is hectic to maintain for the following reasons  difficult to test. difficult in parallel programming  understanding the code...
Read more

Building a Smart Holiday Booking System with Agent-to-Agent Communication

Image
 Building a Multi-Agent Holiday Booking System with the A2A Protocol (An MVP Approach) The world of AI is rapidly moving towards "agentic systems" — autonomous AI agents that can perform complex, multi-step tasks by collaborating with each other. The challenge, however, has always been standardization: how do you get agents built on different frameworks, by different teams, to communicate effectively? This is the problem the  Agent2Agent (A2A) protocol , an open standard, aims to solve. It provides a common language for agents to discover, communicate, and collaborate securely. In this blog post, we'll walk through a Minimum Viable Product (MVP) approach to a real-world scenario: building a holiday booking system using the A2A protocol in python. Design Architecture (MVP) The Problem: A Siloed Booking Experience Imagine a traditional holiday booking website. It might have separate sections for flights, hotels, and cabs. Each of these services is handled by a different int...
Read more

Apache kafka using kraft

Image
Getting Started with Kafka in Kraft Mode: A Step-by-Step Guide Kafka is a powerful platform for real-time data processing. Traditionally, it relied on ZooKeeper for controller election and state management. However, Kraft mode, introduced in Kafka 3.0, offers significant improvements in reliability, performance, and manageability. This blog post provides a step-by-step guide to running Kafka in Kraft mode, helping you unlock its benefits. Let's dive in! Understanding Kafka Configuration Files: Navigating the Configuration Directory: Bash cd /opt/kafka ls config/kraft This command navigates to the Kafka configuration directory and lists files specific to Kraft mode. Configuration File Breakdown: broker.properties : This file manages topic partitioning and data storage/retrieval. controller.properties : Here lies the configuration for Kraft-based leader election. server.properties : This file combines the settings of both broker.properties and controller.properties for a strea...
Read more