Multi-agent crew with MCP and A2A — "Research Studio"

After Phase 4. This project demonstrates the highest-paying skills in 2026: multi-agent orchestration, MCP servers, A2A protocol, deep agents.

What you ship

A research studio that, given a topic, produces a polished Markdown report (~2000 words) with citations and 1-2 charts.

• Multiple specialised agents collaborate.
• Tools are exposed via your own MCP server.
• The whole studio is itself an A2A agent other systems can call.
• A LangGraph deep agent drives planning, sub-agents, and a virtual filesystem.

Architecture (mermaid)

flowchart LR
  CLIENT[Caller agent (LangGraph chat)] -->|A2A tasks/sendSubscribe| A2A[A2A endpoint]
  A2A --> RUNTIME[LangGraph Deep Agent]
  RUNTIME --> PLAN[plan.md]
  RUNTIME --> R[Researcher sub-agent]
  RUNTIME --> AN[Analyst sub-agent]
  RUNTIME --> WR[Writer sub-agent]
  R --> MCP[MCP Server: web_search, fetch_url, save_file]
  AN --> MCP
  WR --> MCP
  RUNTIME --> FS[(Virtual filesystem out/run-id/)]
  RUNTIME -.->|stream| A2A

Stack

• LangGraph with deepagents library (or hand-built deep-agent pattern).
• FastMCP server exposing: web_search, fetch_url, summarise, save_file, read_file.
• a2a-sdk server wrapping the deep agent.
• Tavily for web search (free tier).
• Cohere rerank-3 to filter web search results.
• LangSmith for tracing.
• Streamlit companion app to invoke the A2A endpoint and watch progress.

Step-by-step

Day 1 — MCP server

• Build tools_mcp.py with FastMCP tools (web_search, fetch_url, read_file, write_file, summarise).
• Test with fastmcp dev tools_mcp.py.
• Wire into Claude Desktop and Cursor as a sanity check.

Day 2 — Deep agent runtime

• LangGraph state with goal, plan, files, step_index.
• planner node (creates plan.md), step_runner node (calls a sub-agent), reflect node, conditional cycle.
• Sub-agents (researcher, analyst, writer) are themselves create_agent instances with the MCP tools loaded via langchain-mcp-adapters.

Day 3 — Virtual filesystem

• out/{run_id}/ directory per run.
• Sub-agents write notes.md, references.json, data.csv, report.md.
• Reflection step inspects file presence + size to gauge progress.

Day 4 — A2A wrapper

• Build producer.py that wraps the deep agent in an A2AStarletteApplication.
• Publish an Agent Card at /.well-known/agent.json.
• Stream progress events as A2A messages.

Day 5 — Caller agent

• Build a small LangGraph chat agent on Streamlit that calls the A2A endpoint with a topic.
• Show a live "Plan / Files / Status" panel populated from the A2A stream.

Day 6 — Eval and harden

• Build a 10-topic eval: each with a "perfect report" rubric (LLM-judged 0-1 on completeness, accuracy, structure, citations).
• Add cost meter (tokens_in, tokens_out per sub-agent).
• Add max-step and max-cost ceilings; agent stops gracefully on budget.

Day 7 — Polish

• Write the post explaining each protocol, why you used it, the failure modes you found.
• Demo video: paste a topic, watch the studio plan/research/write live.
• README with mermaid + sample report + cost analysis.

Acceptance checklist

• MCP server runs over stdio and HTTP.
• Agent Card returns valid JSON at /.well-known/agent.json.
• Deep agent successfully completes a 6-step plan with reflection.
• Caller streams progress (Plan, Files, current step) live.
• Cost stays under target (e.g., < $0.30 per report).
• LangSmith trace link.
• A failure mode (Tavily down) is handled gracefully.

What hiring managers love

• Three protocols stacked correctly (LangGraph + MCP + A2A) is rare.
• A virtual filesystem is the #1 indicator the engineer "gets" deep agents.
• Honest cost/quality table.

This project alone clears interviews at every "agent platform" company hiring in 2026.