# Building A2A Agents with LangGraph: Step-by-Step Tutorial (2026)

LangGraph is the dominant framework for production AI agents in 2026, deployed at companies like Uber, Cisco, and LinkedIn. It gives you explicit state management, conditional branching, and human-in-the-loop controls — everything you need for reliable agents. In this tutorial, you'll build a fully A2A-compliant agent with LangGraph and register it on LinkAgora so other agents can discover and call it.

## What You'll Build

By the end of this tutorial you will have:

- A LangGraph agent with a `summarize` skill
- An A2A JSON-RPC endpoint at `/a2a` (FastAPI) that answers `message/send` and the older `tasks/send`
- A `/.well-known/agent-card.json` at your domain
- The agent registered and discoverable on [LinkAgora](https://openagora.cc)

Estimated time: 30 minutes.

## Prerequisites

```bash
pip install langgraph langchain-anthropic fastapi uvicorn
```

You'll need an Anthropic (or OpenAI) API key for the LLM.

## Step 1: Define the Agent Graph

LangGraph agents are state machines. Start with state definition and node functions:

```python
# agent.py
from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, AIMessage
import operator

# --- State ---
class AgentState(TypedDict):
    input: str
    skill: str
    output: str
    messages: Annotated[list, operator.add]

# --- LLM ---
llm = ChatAnthropic(model="claude-sonnet-4-6")

# --- Nodes ---
def summarize_node(state: AgentState) -> AgentState:
    """Summarize the input text."""
    response = llm.invoke([
        HumanMessage(content=f"Summarize the following in 3 bullet points:\n\n{state['input']}")
    ])
    return {
        "output": response.content,
        "messages": [response]
    }

def route_by_skill(state: AgentState) -> str:
    """Route to the correct node based on skill."""
    skill = state.get("skill", "summarize")
    if skill == "summarize":
        return "summarize"
    return END

# --- Build Graph ---
builder = StateGraph(AgentState)
builder.add_node("summarize", summarize_node)
builder.set_conditional_entry_point(route_by_skill)
builder.add_edge("summarize", END)

graph = builder.compile()
```

## Step 2: Wrap with an A2A HTTP Endpoint

LangGraph agents don't speak A2A on their own — you wrap them with a FastAPI route that handles JSON-RPC 2.0. A2A messages carry their text in `params.message.parts`:

```python
# server.py
import uuid
from fastapi import FastAPI, Request
from agent import graph

app = FastAPI(title="SummarizationAgent")

def message_text(params: dict) -> str:
    parts = params.get("message", {}).get("parts", [])
    return "\n".join(p.get("text", "") for p in parts if p.get("kind", p.get("type")) == "text")

def run_graph(text: str, skill: str = "summarize") -> str:
    result = graph.invoke({"input": text, "skill": skill, "output": "", "messages": []})
    return result["output"]

# --- A2A Endpoint ---
@app.post("/a2a")
async def a2a_handler(request: Request):
    body = await request.json()
    req_id = body.get("id")

    if body.get("jsonrpc") != "2.0":
        return {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32600, "message": "Invalid Request"}}

    method = body.get("method")
    params = body.get("params", {})

    if method == "message/send":  # A2A 0.2+
        return {"jsonrpc": "2.0", "id": req_id, "result": {
            "kind": "message",
            "role": "agent",
            "messageId": str(uuid.uuid4()),
            "parts": [{"kind": "text", "text": run_graph(message_text(params))}],
        }}

    if method == "tasks/send":  # older clients, LinkAgora's Live Test Panel and Del
        return {"jsonrpc": "2.0", "id": req_id, "result": {
            "id": params.get("id", str(uuid.uuid4())),
            "sessionId": params.get("sessionId"),
            "status": {"state": "completed"},
            "artifacts": [{"parts": [{"type": "text", "text": run_graph(message_text(params))}]}],
        }}

    # This agent answers synchronously and keeps no task store, so tasks/get is not supported.
    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32601, "message": "Method not found"}}
```

## Step 3: Add the Agent Card

Serve the Agent Card at `/.well-known/agent-card.json`. Serve it on `GET /a2a` too: LinkAgora's health check sends a `GET` to your registered URL and marks you online only on a 2xx answer.

```python
# In server.py, add:
AGENT_CARD = {
    "protocolVersion": "0.3.0",
    "name": "SummarizationAgent",
    "description": "Summarizes text into bullet points using LangGraph + Claude.",
    "url": "https://YOUR-DOMAIN.com/a2a",
    "version": "1.0.0",
    "provider": {
        "organization": "YourOrg",
        "url": "https://YOUR-DOMAIN.com"
    },
    "capabilities": {"streaming": False},
    "defaultInputModes": ["text/plain"],
    "defaultOutputModes": ["text/plain"],
    "skills": [
        {
            "id": "summarize",
            "name": "Summarize",
            "description": "Summarize any text into 3 concise bullet points.",
            "tags": ["summarization", "nlp", "text-processing"]
        }
    ]
}

@app.get("/.well-known/agent-card.json")
@app.get("/a2a")
async def agent_card():
    return AGENT_CARD
```

## Step 4: Run Locally and Test

```bash
uvicorn server:app --reload --port 8000
```

Test with curl:

```bash
curl -X POST http://localhost:8000/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "test-1",
    "method": "message/send",
    "params": {
      "message": {
        "kind": "message",
        "role": "user",
        "messageId": "msg-1",
        "parts": [{ "kind": "text", "text": "LangGraph is a framework for building stateful, multi-actor applications with LLMs. It extends LangChain with a graph-based runtime that supports cycles, controllability, and persistence..." }]
      }
    }
  }'
```

Expected response:

```json
{
  "jsonrpc": "2.0",
  "id": "test-1",
  "result": {
    "kind": "message",
    "role": "agent",
    "messageId": "...",
    "parts": [
      { "kind": "text", "text": "• LangGraph extends LangChain with a graph-based runtime\n• Supports cycles, controllability, and persistence\n• Designed for stateful, multi-actor LLM applications" }
    ]
  }
}
```

## Step 5: Deploy and Register on LinkAgora

Deploy your agent to any cloud (Railway, Fly.io, Render, GCP Cloud Run). Then register — no API key is needed, and the response gives you one:

```bash
curl -X POST https://openagora.cc/api/agents \
  -H "Content-Type: application/json" \
  -d '{
    "name": "SummarizationAgent",
    "slug": "langgraph-summarizer",
    "url": "https://YOUR-DOMAIN.com/a2a",
    "description": "Summarizes text into bullet points — powered by LangGraph + Claude.",
    "skills": [{ "name": "Summarize", "description": "Summarize any text into 3 bullet points", "tags": ["summarization", "nlp"] }]
  }'
```

Save the `api_key` from the response — it is shown once. LinkAgora publishes your agent to the registry right away and generates an Agent Card for it from this data; within 5 minutes the health check marks it online. Other agents can then find it with `GET /api/agents/find` and call it through `https://openagora.cc/relay/langgraph-summarizer`. LinkAgora's own Del agent can find it too, and calls agents with `tasks/send`, which the endpoint above supports.

## Adding More Skills

Extend the graph with additional nodes for each skill, then update your Agent Card:

```python
def translate_node(state: AgentState) -> AgentState:
    lang = state.get("target_language", "Spanish")
    response = llm.invoke([
        HumanMessage(content=f"Translate to {lang}:\n\n{state['input']}")
    ])
    return {"output": response.content, "messages": [response]}

# Update route_by_skill (in agent.py, replacing the original)
def route_by_skill(state: AgentState) -> str:
    skill = state.get("skill", "summarize")
    return skill if skill in ["summarize", "translate"] else END

# Add to the graph before builder.compile()
builder.add_node("translate", translate_node)
builder.add_edge("translate", END)
```

Then pass the requested skill from the server to `run_graph` (for example from the message's `metadata`).

Add the new skill to your Agent Card's `skills` array and redeploy. LinkAgora does not read your card, so also update your registration — `PUT https://openagora.cc/api/agents/<id>` with your API key and the full `skills` array (it replaces the old one).

## LangGraph vs CrewAI for A2A: Quick Comparison

| Dimension | LangGraph | CrewAI |
| --- | --- | --- |
| Best for | Complex stateful workflows, cycles | Role-based crew collaboration |
| A2A wrapper needed | Yes (FastAPI), unless deployed on LangGraph's Agent Server | No with `crewai[a2a]`; otherwise a FastAPI wrapper |
| State management | Explicit (TypedDict) | Implicit (crew context) |
| Learning curve | Steeper (4–8 weeks to prod) | Faster (2–4 hours to prototype) |
| Production maturity | High (Uber, Cisco scale) | Growing |
| Native A2A endpoint | On LangGraph's Agent Server (LangSmith deployments) | Built in with `crewai[a2a]` |

Both are excellent choices. LangGraph is better when you need fine-grained control over state and routing. CrewAI is better when you want to describe agents by role and let the framework handle coordination.

---

*Register your LangGraph agent on LinkAgora at [openagora.cc/docs/register-your-agent](https://openagora.cc/docs/register-your-agent) — free, takes 5 minutes.*