PyData · Published 2026-08-25

Building Agentic Systems with Python, LangGraph, MCP, and A2A [PyCon DE & PyData 2026]

privateReview: unreviewedConfidence: high
langgraphMCPA2Aagentspythonfastapihub-and-spokeagent-orchestrationcontext-managementai-generated-testsgroundedness
Open on YouTube ↗

Summary

Overview

  • Speaker: Holger Nösekabel
  • Channel: PyData
  • Main topic: Building AI Agentic Systems using Python, LangGraph, Model Context Protocol (MCP), and Agent-to-Agent (A2A) communication.
  • Purpose: Provide architectural insights and practical lessons learned from building enterprise-grade agentic systems in Python. Holger Nösekabel, CTO at TD Reply, discusses the architectural patterns, challenges, and practical solutions for building AI-driven agentic systems. Using a real-world M&A company scouting and evaluation use case, he explains the roles of static versus dynamic data, Model Context Protocol (MCP) for tool exposure, Agent-to-Agent (A2A) protocols, and LangGraph workflow orchestration over purely prompt-driven autonomy.

Topic Map

Introduction and Motivation

  • Explanation: Setting the context of AI as the engine and data as the fuel, highlighting why static data is insufficient and dynamic, flexible architectures are required for modern AI tools.
  • Key claims:
    • AI is the engine of today, data is still the fuel.
    • Static data does not suffice; AI tooling evolves rapidly and flexibility is needed.
  • Examples:
    • Mention of LangChain 0.1 to 0.2 rewrite cycles.
  • Terminology:
    • LLM
    • AI tools
    • static data
    • dynamic data
    • loose coupling
  • Why it matters: Establishes the business and technical need for dynamic agentic architectures.

Practical Project: M&A Company Scouting

  • Explanation: Outlining a real-world project at TD Reply to automatically identify, score, and evaluate potential M&A target companies using AI.
  • Key claims:
    • AI can do the heavy lifting of identifying companies fitting an ecosystem.
    • Data sources include partner websites, LinkedIn, Perplexity AI, web crawling, and Google/Wikipedia.
  • Examples:
    • Company scorecard web tool with revenue, headcount, CEO, and industry categorization.
  • Terminology:
    • M&A
    • company profiling
    • scorecard
    • data sources
    • Perplexity AI
  • Why it matters: Demonstrates the practical application and complexity of real-world agentic workflows.

Technical Architecture

  • Explanation: Detailed breakdown of the tech stack: FastAPI conversational interface, coordination agent, hub-and-spoke worker agents, SQLite/Neo4j knowledge bases, and Redis for server-side events.
  • Key claims:
    • Hub-and-spoke model separates worker agents so they do not need to talk to each other.
    • SQLite is more than sufficient for knowledge base storage without needing Oracle or Kafka.
  • Examples:
    • List Agent, Company Info Agent, Check Agent, Evaluation Agent, Outreach Agent, Update Agent.
  • Terminology:
    • FastAPI
    • Nginx
    • coordinator agent
    • SQLite
    • Neo4j
    • Redis
  • Why it matters: Provides a blueprint for structuring production-grade multi-agent systems.

Model Context Protocol (MCP) & A2A

  • Explanation: Explanation of MCP for exposing tools to agents and A2A for agent-to-agent communication.
  • Key claims:
    • MCP exposes tools securely via standard interfaces (HTTP, stdio).
    • A2A acts like a business card allowing agents to discover and query other agents.
  • Examples:
    • FastMCP decorator setup for web search tools.
  • Terminology:
    • MCP
    • Model Context Protocol
    • A2A
    • FastMCP
    • A2ACardResolver
  • Why it matters: Standardizes how agents consume tools and interact with other agents.

Control Your Agent: Prompt vs Workflow

  • Explanation: Comparing pure prompt-driven agent autonomy with LangGraph structured workflows.
  • Key claims:
    • Too much agent autonomy leads to unpredictable behavior and incomplete tasks.
    • LangGraph workflows allow explicit control over tool execution (loops, parallel execution, branches).
  • Examples:
    • Comparing prompt instructions vs LangGraph explicit state graph workflows.
  • Terminology:
    • LangGraph
    • autonomy
    • prompt engineering
    • workflow options
    • parallel execution
  • Why it matters: Addresses reliability and determinism in agentic systems.

QA, Testing, and Metrics

  • Explanation: Using AI for quality assurance, automated testing, evaluation metrics, and monitoring traces.
  • Key claims:
    • Let AI help write test cases and cover edge cases.
    • Check Agent validates user requests against malicious prompts and verifies data consistency.
  • Examples:
    • Evaluating semantic SQL correctness, hallucination rate, and groundedness score.
  • Terminology:
    • QA
    • automated testing
    • hallucination rate
    • groundedness
    • tracing
    • Check Agent
  • Why it matters: Ensures reliability, security, and quality assurance in production AI systems.

Key Points

Data is the fuel

  • Explanation: While LLMs and AI are powerful engines, obtaining fresh, dynamic, and accurate data is critical to getting valuable results.
  • Evidence: Static data lacks new insights; scraping and Perplexity AI provide dynamic company data.
  • Practical implication: Invest heavily in robust data collection pipelines alongside LLM integration.

Workflows beat pure prompts

  • Explanation: Allowing agents complete autonomy through prompts often results in skipped tools or incomplete execution.
  • Evidence: Helper functions counting tool calls or LangGraph enforcing parallel execution prevent agent failure.
  • Practical implication: Use structured workflows (LangGraph) when precise control over tool execution order is required.

Keep MCP tool count manageable

  • Explanation: Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.
  • Evidence: Giving developers too much background documentation causes cognitive overload; same applies to LLMs.
  • Practical implication: Curate and filter MCP tools to only what the agent strictly needs.

Let AI help test AI

  • Explanation: Writing test cases, code coverage checks, and edge case detection can be automated using LLMs.
  • Evidence: AI can analyze source code and generate comprehensive test suites quickly.
  • Practical implication: Leverage LLMs for automated unit test generation and debugging assistance.

Frameworks, Models & Processes

Hub-and-Spoke Multi-Agent Architecture

  • How it works: A central coordinator agent receives user requests, parses them, and dispatches subtasks to specialized worker agents.
  • Components:
    • Conversational Interface
    • FastAPI Server
    • Coordinator Agent
    • Worker Agents (List, Company Info, Check, Evaluation, Outreach, Update)
    • Knowledge Base (SQLite, Neo4j)
    • Redis Event Store
  • When to use: When building complex multi-step systems requiring separation of concerns across specialized domains.

LangGraph Workflow Patterns

  • How it works: Defines execution paths using loops, parallel processing, and conditional branching.
  • Components:
    • Loop Pattern (ReAct)
    • Parallel Pattern (Fan-out / Merge)
    • Branch Pattern (Conditional routing)
  • When to use: When deterministic execution order, parallel data gathering, or conditional business logic is required.

Examples & Case Studies

Building an AI-driven M&A scouting tool at TD Reply.

  • Illustrates: Combining web crawling, Perplexity AI, and LinkedIn data to score and evaluate target companies.
  • Lesson: Automating M&A scouting saves significant manual research time while maintaining high data accuracy.

Encountering debugging issues when connecting backend services to controller agents.

  • Illustrates: The difficulty of diagnosing silent failures in multi-agent tool calls without proper tracing.
  • Lesson: Using AI for debugging and feeding console log output back to LLMs speeds up troubleshooting dramatically.

Actionable Takeaways

  • Immediate:
    • Use FastMCP to easily expose Python functions as standardized tools.
    • Keep the number of MCP tools assigned to a single agent under control.
    • Implement structured workflows in LangGraph instead of relying solely on prompt instructions.
  • Strategic:
    • Technology is an enabler, not a driver; anchor agentic systems in clear business value.
    • Incorporate robust QA, tracing, and automated test generation for production AI systems.
    • Make backends clients of A2A protocols when agents already support A2A communication.
  • Questions to investigate:
    • How to scale A2A protocol security and authentication across distributed enterprise networks?
    • What are the optimal cost-to-accuracy trade-offs when combining multiple paid web search APIs?

Claims Worth Verifying

  • SQLite is sufficient for enterprise agent knowledge bases without needing Kafka or Oracle. (architectural opinion)
  • Perplexity AI is significantly cheaper than Bloomberg or strict curated catalog subscriptions. (cost comparison)

Notable Quotes

"AI is the engine of today. Data is still the fuel." (at 0:25) "Technology is an enabler — not a driver." (at 55:15) "Trust but verify." (at 32:07)

Compressed Summary

  • Dynamic data and fresh sources are essential for high-quality agent outputs.
  • MCP standardizes tool exposure; A2A enables agent-to-agent collaboration.
  • LangGraph workflows provide necessary control over agent autonomy and execution order.
  • Automated testing and QA powered by AI drastically reduce debugging overhead.
  • Keywords: langgraph, mcp, a2a, agents, python, fastapi
  • Core insight: Building reliable agentic systems requires moving beyond pure prompt autonomy into structured LangGraph workflows, standardized MCP tooling, and rigorous AI-assisted QA.

Core insights

6
Architecturemedium noveltymoderate evidence

For agentic systems with a known task shape, explicit workflow graphs (LangGraph loops, parallel fan-out/merge, branches) are more reliable than letting a prompt-driven agent autonomously choose tool calls, because autonomous agents skip tools and finish incompletely.

Why it matters

Reliability and determinism in production come from encoding control flow where possible and leaving LLM choice only where it is genuinely needed.

Generalization

As agent tasks move from demos to production, developers should shift from 'give the LLM tools and a prompt' to 'model the process as a graph and use the LLM for steps inside the graph'.

Too much agent autonomy leads to unpredictable behavior and incomplete tasks.
Open source video
LangGraph workflows allow explicit control over tool execution (loops, parallel execution, branches).
Open source video
Helper functions counting tool calls or LangGraph enforcing parallel execution prevent agent failure.
Open source video
Architecturemedium noveltymoderate evidence

Hub-and-spoke architecture—one coordinator agent parsing requests and dispatching to specialized worker agents—removes the need for workers to communicate with each other and is a practical boundary for multi-agent systems.

Why it matters

It contains agent interactions to a single controlled handoff point instead of forming an unmanageable peer-to-peer graph.

Generalization

Any multi-agent product can reduce coupling by making one coordinator own routing and making workers unaware of each other.

A central coordinator agent receives user requests, parses them, and dispatches subtasks to specialized worker agents.
Open source video
Hub-and-spoke model separates worker agents so they do not need to talk to each other.
Open source video
Failure Modehigh noveltymoderate evidence

Connecting too many MCP servers is a context-economics failure mode, not just an integration problem: every added tool's documentation consumes the agent's limited context and can overwhelm real task decisions.

Why it matters

Team leads tend to maximize tool coverage, but the limiting resource is context; tool surface must be curated just like code APIs.

Generalization

An agent's tool API should be scoped per agent or per task instead of exposing every available integration to every agent.

Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.
Open source video
Giving developers too much background documentation causes cognitive overload; same applies to LLMs.
Open source video
Curate and filter MCP tools to only what the agent strictly needs.
Open source video
Mechanismmedium noveltymoderate evidence

MCP and A2A play complementary roles: MCP standardizes exposing tools to agents over HTTP/stdio, while A2A is an agent discovery and query contract ('business card'), making interoperability an architectural goal rather than an integration afterthought.

Why it matters

Using standard protocols for tool exposure and agent discovery prevents point-to-point custom glue code and lets agent systems evolve independently.

Generalization

Agent ecosystems are moving toward layered contracts: one protocol between agents and capabilities, another between agents themselves.

MCP exposes tools securely via standard interfaces (HTTP, stdio).
Open source video
A2A acts like a business card allowing agents to discover and query other agents.
Open source video
Standardizes how agents consume tools and interact with other agents.
Open source video
Practicemedium noveltymoderate evidence

AI can be effectively used to produce QA artifacts and safety signal for AI systems: LLM-generated test cases cover edge cases, and dedicated check agents test for malicious prompts, SQL correctness, hallucinations, and grounding.

Why it matters

Production agent systems need a QA loop that is itself automated, and the same LLM capabilities that create AI behavior can be used to instrument and police it.

Generalization

Agent engineering should include automated adversarial validation and semantic verification of model outputs, not only functional unit tests.

Let AI help write test cases and cover edge cases.
Open source video
Check Agent validates user requests against malicious prompts and verifies data consistency.
Open source video
Evaluating semantic SQL correctness, hallucination rate, and groundedness score.
Open source video
Architecturemedium noveltymoderate evidence

Lightweight infrastructure choices such as SQLite for a knowledge base can be sufficient for production agent workloads; over-engineering storage (Oracle, Kafka) is not what makes an agentic system work.

Why it matters

Operational cost and complexity often dominate agent-system cost; choosing simple, embeddable components can greatly lower the barrier to building production systems.

Generalization

When designing an agentic system, choose the smallest data infrastructure that satisfies the workflow; scale only after the agent behavior is proven.

SQLite is more than sufficient for knowledge base storage without needing Oracle or Kafka.
Open source video

Deep dives

4

Workflow determinism vs agent autonomy: decision rules for graph-enforced control flow

Research question

Under which task conditions does graph-enforced control flow outperform prompt-driven autonomy in task completion and cost, and can those conditions be predicted from task structure and tool-count requirements?

Why

The talk reports that autonomous agents skip tools and finish incompletely, but offers no precise criterion for when to fix execution order in a LangGraph versus letting the LLM choose. A decision rule would help production teams choose the right orchestration pattern without over-constraining flexible tasks.

Too much agent autonomy leads to unpredictable behavior and incomplete tasks.
Open source video
LangGraph workflows allow explicit control over tool execution (loops, parallel execution, branches).
Open source video
Source video

Dynamic MCP tool curation and context-economics

Research question

Can an agent-side tool registry that activates only a task-relevant subset of MCP tools reduce context waste and improve tool-selection accuracy without losing needed capabilities?

Why

Context overload from too many MCP servers is identified as a real failure mode, but 'curate and filter' is underspecified. As MCP ecosystems grow, per-agent dynamic filtering becomes the main defense against context pollution.

Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.
Open source video
Curate and filter MCP tools to only what the agent strictly needs.
Open source video
Source video

Scaling and failure modes of hub-and-spoke coordinator patterns

Research question

How does coordinator routing latency and error rate scale with the number of worker agents and concurrent requests, and where does the coordinator become the bottleneck?

Why

Hub-and-spoke is proposed as a coupled-reducing architecture, but the coordinator becomes a central control-plane dependency whose saturation behavior is unstudied. Understanding this is critical for production deployments.

Hub-and-spoke model separates worker agents so they do not need to talk to each other.
Open source video
Source video

Operationalizing groundedness and hallucination metrics in agent QA loops

Research question

What concrete methods can reliably compute groundedness scores and semantic SQL correctness checks for agent outputs, and what thresholds correspond to acceptable human-judged quality?

Why

The talk lists hallucination rate and groundedness as evaluation metrics but does not specify how they are measured or calibrated. Without a reproducible measurement, AI-generated QA cannot be trusted as a safety gate in production systems.

Evaluating semantic SQL correctness, hallucination rate, and groundedness score.
Open source video
Source video

Article ideas

4

Your Agent Doesn't Need More Tools; It Needs Fewer, Curated Ones

The dominant failure mode in agentic systems is not missing tool integration but context saturation from over-connected MCP servers, so agent platforms should treat tool registries as a first-class curation layer that filters tool contracts per agent and per task.

Angle

Use the talk's M&A worker example to show how each worker only sees the MCP tools it needs, making the architecture more reliable than a single mega-agent with every server connected.

Source video

From Autonomous Agents to Orchestrated Workflows: Why Graph Control Is the New Production Default

Production agentic systems are moving from prompt-driven autonomy to explicit workflow graphs because autonomy produces skipped steps, and LangGraph-style loops, branches, and parallel fan-out encode the 'happy path' while still allowing LLM judgment where it matters.

Angle

Contrast 'demo agents' with 'enterprise processes' and use the M&A scoring flow to show how enforceability beats flexibility for repeatable tasks.

Source video

MCP + A2A: The Two-Protocol Architecture That Tames Multi-Agent Interop

MCP and A2A solve different problems—capability exposure and agent discovery—and together create a separation of concerns that lets enterprises replace tools and agents without rewriting glue code, effectively turning agent composition into a standards-based platform problem.

Angle

Frame the 'business card' analogy for A2A and contrast it with MCP's 'tool USB port'; use the talk's FastMCP example and the coordinator/worker split as a concrete illustration.

Source video

SQLite Over Kafka: Choosing the Smallest Infrastructure That Makes Agents Work

The success of an agentic system is determined by workflow correctness and data quality, not by heavyweight infrastructure, and choosing SQLite over Oracle or Kafka for a production knowledge base exposes hidden cost savings and faster iteration without sacrificing capability.

Angle

Use the talk's admission that SQLite was sufficient as a rebuttal to default over-engineering in AI application stacks, and argue for a 'scale after proven behavior' principle.

Source video

Project ideas

3

Agent Workflow Enforcement Benchmark

movement-lab

For domain tasks with a known step sequence, LangGraph-enforced control flow achieves at least 40% higher task completion rate than a prompt-driven autonomous agent given the same tools, while not degrading outcomes on open-ended goals.

Proof of concept

Build a small benchmark of 3 task families (data collection, validation, report generation) where the graph is fixed for one variant and the other is prompt-only; run both with identical API budget.

Measurement

Percentage of tasks completed without missing required tool calls; output completeness; number of tool calls per completed task.

Source video

Context-Aware Tool Filtering for MCP

gatehouse

Given a task query and a pool of 20+ MCP tool descriptions, a lightweight retrieval filter that exposes only the top-k relevant tools to an agent will improve task accuracy or reduce token cost by at least 30% compared with exposing all tools, while retaining the capability to invoke any tool.

Proof of concept

Prototype a FastMCP gateway that embeds tool descriptions and queries, and for each user/agent request selects a subset of MCP tools. Add a 'fallback: ask for expansion' behavior so unseen tools remain discoverable.

Measurement

Task success rate, context tokens consumed, tool-selection precision/recall versus an oracle, and user/agent queries for additional tools.

Source video

Agentic QA Check Loop

beyond-evals

An automated check agent that validates SQL outputs for semantic correctness and grounding against source data will catch at least 50% more real errors than conventional assertions or rule-based checks on the same agent workflow.

Proof of concept

Use the M&A company-scoring scenario: add a check agent between the evaluation agent and the report generator. Feed it source data plus generated SQL and ask it to verify semantic correctness and groundedness for each claim.

Measurement

Precision/recall of hallucinated or ungrounded claims detected versus a human-labeled test set; false-positive rate.

Source video

Architectural implications

5

Agent systems need both conversational interaction and background workflow control.

Before

A single loop often lets the model decide what tool to call next and in what order.

After

Use a coordinator plus an explicit state graph (LangGraph) to express ordered, parallel, and conditional tool execution.

Consequence

System behavior becomes more deterministic and auditable, while each agent still uses a language model where it adds value.

Source video

Workers in a system can have focused, mutually exclusive jobs.

Before

Agents may call each other directly or attempt broad multi-step tasks.

After

A hub-and-spoke coordinator dispatches each worker's subproblem; workers do not address each other.

Consequence

Agent topology remains simple, failure isolation improves, and the coordinator is the single place to inspect orchestration.

Source video

Every MCP server adds tool descriptions to the agent context.

Before

Tool surface is whatever servers are connected, and adding servers is seen as adding capability.

After

Tool discovery and filtering become part of the agent runtime; each agent sees only relevant tool contracts.

Consequence

Lower context pollution, fewer accidental tool selections, but requires a tool-curation layer in the platform.

Source video

Fresh, wide, dynamic data is required for agent output to be valuable beyond static tables.

Before

An agent is viewed as the main component and data as a secondary snapshot.

After

Data acquisition is a first-class subsystem: crawling, collaborative sources, and search APIs feed the agent pipeline.

Consequence

Agent value becomes dominated by data freshness pipelines and tool integrations as much as by model choice.

Source video

There are two protocol boundaries in a mature agent system: agent-to-capability and agent-to-agent.

Before

Tools and agents are linked with custom code and direct imports.

After

MCP standardizes tool access; A2A standardizes agent discovery and requests.

Consequence

System components can be independently replaced and reused across organizational boundaries.

Source video

Tradeoffs and failure modes

4

Workflow determinism vs agent autonomy

Benefit

An explicit LangGraph workflow prevents skipped calls and incomplete jobs by enforcing exact control flow.

Cost or risk

Highly predetermined workflows can reduce flexibility for unforeseen inputs; pattern choice matters per use case.

Too much agent autonomy leads to unpredictable behavior and incomplete tasks.
Open source video
Source video

MCP tool breadth vs context capacity

Benefit

Exposing many tools means the agent can handle more capability requests.

Cost or risk

Each tool's documentation occupies context, and irrelevant tools become a source of decisions the model should not have to make.

Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.
Open source video
Source video

Worker specialization vs coordination overhead

Benefit

Workers remain simple and unaware of each other, so each domain can be built, tested, and scaled independently.

Cost or risk

The coordinator agent becomes a control-plane dependency and must correctly parse and route user intent.

Hub-and-spoke model separates worker agents so they do not need to talk to each other.
Open source video
Source video

AI-generated tests vs semantic reliability

Benefit

LLM-based test generation can quickly cover edge cases and tool-call-consistency checks.

Cost or risk

The tests and metrics themselves need grounding and hallucination checks; evaluation quality is only as good as its guardrails.

Evaluating semantic SQL correctness, hallucination rate, and groundedness score.
Open source video
Source video

Open questions

4

What is a practical decision rule for when to use LangGraph workflow patterns versus leaving the model fully autonomous?

Why unresolved

The talk reports that autonomy caused incomplete tasks, but does not provide a precise criterion separating fixed process from open-ended reasoning.

Research direction

Benchmark task structure, number of required tool calls, and cost/risk of incomplete execution to derive a workflow/autonomy classifier.

Source video

How should MCP tools be curated and filtered per agent without losing needed capabilities the agent did not know about in advance?

Why unresolved

Context overload is acknowledged, but the recommendation is only 'curate and filter'; discovery and per-request selection are not specified.

Research direction

Prototype dynamic tool registries, embeddings or heuristic filters that activate the smallest relevant tool set for a task.

Source video

How are groundedness and hallucination metrics computed operationally and what thresholds are acceptable in this decision flow?

Why unresolved

The summary names the metrics but gives neither exact computation nor production calibration data.

Research direction

Build reference evaluations and human audits around semantic correctness and SQL grounding for agent workflows.

Source video

What are the failure modes of the hub-and-spoke coordinator when request volume or worker count grows?

Why unresolved

Hub-and-spoke appears to be sufficient in the described project, but saturation of the coordinator and delay behavior are not covered.

Research direction

Experiment with asynchronous dispatch, routing by intent classification, and coordinator replication for high fan-out workloads.

Source video

Key claims

7
causalVerification needed

Too much agent autonomy leads to unpredictable behavior and incomplete tasks.

Evidence

Too much agent autonomy leads to unpredictable behavior and incomplete tasks.

Question

How much better do LangGraph workflows perform than prompt-driven autonomy on a standardized multi-step agent benchmark?

Source video
comparativeVerification needed

LangGraph workflows allow explicit control over loops, parallel execution, and branches, preventing skipped tool calls.

Evidence

LangGraph workflows allow explicit control over tool execution (loops, parallel execution, branches).

Question

Do graph-enforced workflows consistently reduce tool-skip rates compared with prompt-only instructions across task families?

Source video
causalVerification needed

Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.

Evidence

Connecting too many MCP servers overloads the agent context with irrelevant tool documentation.

Question

What is the relationship between number of irrelevant MCP tools and task accuracy/context utilization?

Source video
factualVerification needed

A hub-and-spoke model means worker agents need not talk to each other.

Evidence

Hub-and-spoke model separates worker agents so they do not need to talk to each other.

Question

Is hub-and-spoke sufficient for domains requiring negotiation or delegation between specialized workers?

Source video
opinionVerification needed

SQLite is sufficient for knowledge base storage without needing Oracle or Kafka in this class of agent system.

Evidence

SQLite is more than sufficient for knowledge base storage without needing Oracle or Kafka.

Question

At what write/query concurrency or graph scale does SQLite become a bottleneck for agentic knowledge workflows?

Source video
factualVerification needed

AI can analyze source code and generate comprehensive test suites quickly.

Evidence

AI can analyze source code and generate comprehensive test suites quickly.

Question

What code coverage and defect-detection rate do LLM-generated test suites achieve relative to human-written suites?

Source video
factualVerification needed

A2A acts as a business card allowing agents to discover and query other agents.

Evidence

A2A acts like a business card allowing agents to discover and query other agents.

Question

How does A2A discovery scale and challenge traditional service discovery in production agent deployments?

Source video

Connections

5