Two agentic systems, two different stacks. Here's what actually differed under the hood — not the marketing-slide differences, but the ones that showed up while I was building, debugging, and grounding real agents in production.
I shipped two agent systems on deliberately different foundations:
- Watchlist shortlisting agent — native AWS Bedrock. Custom MCP servers + A2A protocol, Titan embeddings, Claude for reasoning.
- Yuvan (voice-first math tutor) — LangGraph + LangChain + GPT-4o-mini, pgvector, LangSmith for tracing and evals.
Same core problem both times: orchestrate specialist agents, fuse their outputs, and keep reasoning grounded. Very different ergonomics getting there.
Orchestration: a protocol vs. a state machine
On the watchlist agent, an Orchestrator talks to an Analyst agent and a News agent over A2A — structured messages passed between autonomous services, each owning its own MCP server as a hard tool boundary. The agents are genuinely separate systems that happen to cooperate.
On Yuvan, LangGraph models the whole flow as one explicit graph, with shared state threaded through every node:
RAG → generate → verify → tag → persist
The takeaway: A2A/MCP wins when agents are genuinely separate systems with their own lifecycles and tool boundaries. LangGraph wins when you want one coherent, inspectable flow you can reason about end to end.
Evals separated the two more than I expected
This is where the gap was widest. LangSmith on Yuvan gave me per-node traces, dataset-driven regression runs, and a way to actually diff prompt changes instead of eyeballing them. Every doubt is replayable — I can point at a specific node, a specific input, and see exactly what happened.
On the Bedrock side I leaned on Bedrock's own evaluation flow. It's solid for grounding and quality scoring, but nowhere near the same granularity for debugging a multi-step chain. If you're iterating fast on a graph, trace-level observability isn't a nice-to-have — it's the difference between reasoning about your system and guessing at it.
Grounding is the hard part in both
Neither stack saves you from hallucination. The framework is not your guardrail — you are.
- Watchlist: reasoning constrained strictly to structured scores + retrieved news. The model doesn't get to invent context it wasn't handed.
- Yuvan: a math verifier re-checks every numerical claim before the AI is allowed to speak it.
Same discipline, different tools: the model proposes, your guardrails dispose.
The framework is not the architecture
A2A/MCP and LangGraph answer the same question — how do specialist agents cooperate without collapsing into spaghetti — under different constraints. One gives you a protocol between autonomous services; the other gives you a state machine you can hold in your head. Knowing when to reach for which is the actual skill. The framework choice follows from the architecture, not the other way around.
Still refining
If you're running A2A/MCP in production, how are you handling agent versioning across the message contract? When one agent's schema evolves, keeping the contract backward compatible without freezing every downstream consumer is the piece I'm still working out. If you've solved this cleanly, I'd like to hear how.