During the process of running the unit tests, we encountered an ImportError related to numpy and libstdc++.so.6. The error message is: ImportError: libstdc++.so.6: cannot open shared object file: No such file or directory. This error indicates that the numpy package is looking for a specific C++ standard library that is either missing or not in the library path where it's expected. This is a system-level dependency issue and might require modifying the environment outside the Python virtual environment. The same error happens within nix shell, this means that the error is related to how numpy is built or linked within this particular environment and might require a more tailored configuration of the nix-shell.

Here are the steps we have taken so far to solve the issue:

1. We first tried running the test. The tests failed to run because of ModuleNotFoundError errors. This indicates that the test files are unable to locate the necessary modules.
2. We then tried to add the samples/python directory to the PYTHONPATH environment variable so that Python can locate the modules correctly. The tests failed again with an ImportError related to numpy and libstdc++.so.6.
3. We then reinstalled the numpy package, but the error persisted.
4. We then updated the shared library cache, but this also did not solve the issue.
5. We then tried installing libstdc++.so.6 in the system, but the error persisted.
6. We then tried to use nix-shell to enter a development shell with all the dependencies specified in shell.nix and we ran the tests from within that shell. The error persisted.
7. We then removed the existing virtual environment, and all the packages installed there. Then, we tried to reinstall the python packages from within nix-shell. The error persisted.

We need to investigate the nix file further and ask for help to solve this problem. An open protocol enabling communication and interoperability between opaque agentic applications.

• Agent2Agent Protocol A2A
  • Getting Started
  • Contributing
  • What's next
  • About

One of the biggest challenges in enterprise AI adoption is getting agents built on different frameworks and vendors to work together. That’s why we created an open Agent2Agent (A2A) protocol, a collaborative way to help agents across different ecosystems communicate with each other. Google is driving this open protocol initiative for the industry because we believe this protocol will be critical to support multi-agent communication by giving your agents a common language – irrespective of the framework or vendor they are built on. With A2A, agents can show each other their capabilities and negotiate how they will interact with users (via text, forms, or bidirectional audio/video) – all while working securely together.

Watch this demo video to see how A2A enables seamless communication between different agent frameworks.

The Agent2Agent (A2A) protocol facilitates communication between independent AI agents. Here are the core concepts:

• Agent Card: A public metadata file (usually at /.well-known/agent.json) describing an agent's capabilities, skills, endpoint URL, and authentication requirements. Clients use this for discovery.
• A2A Server: An agent exposing an HTTP endpoint that implements the A2A protocol methods (defined in the json specification). It receives requests and manages task execution.
• A2A Client: An application or another agent that consumes A2A services. It sends requests (like tasks/send) to an A2A Server's URL.
• Task: The central unit of work. A client initiates a task by sending a message (tasks/send or tasks/sendSubscribe). Tasks have unique IDs and progress through states (submitted, working, input-required, completed, failed, canceled).
• Message: Represents communication turns between the client (role: "user") and the agent (role: "agent"). Messages contain Parts.
• Part: The fundamental content unit within a Message or Artifact. Can be TextPart, FilePart (with inline bytes or a URI), or DataPart (for structured JSON, e.g., forms).
• Artifact: Represents outputs generated by the agent during a task (e.g., generated files, final structured data). Artifacts also contain Parts.
• Streaming: For long-running tasks, servers supporting the streaming capability can use tasks/sendSubscribe. The client receives Server-Sent Events (SSE) containing TaskStatusUpdateEvent or TaskArtifactUpdateEvent messages, providing real-time progress.
• Push Notifications: Servers supporting pushNotifications can proactively send task updates to a client-provided webhook URL, configured via tasks/pushNotification/set.

Typical Flow:

1. Discovery: Client fetches the Agent Card from the server's well-known URL.
2. Initiation: Client sends a tasks/send or tasks/sendSubscribe request containing the initial user message and a unique Task ID.
3. Processing:
   • (Streaming): Server sends SSE events (status updates, artifacts) as the task progresses.
   • (Non-Streaming): Server processes the task synchronously and returns the final Task object in the response.
4. Interaction (Optional): If the task enters input-required, the client sends subsequent messages using the same Task ID via tasks/send or tasks/sendSubscribe.
5. Completion: The task eventually reaches a terminal state (completed, failed, canceled).

• 📚 Read the technical documentation to understand the capabilities
• 📝 Review the json specification of the protocol structures
• 🎬 Use our samples to see A2A in action
  • Sample A2A Client/Server (Python, JS)
  • Multi-Agent Web App
  • CLI (Python, JS)
• 🤖 Use our sample agents to see how to bring A2A to agent frameworks
  • Agent Developer Kit (ADK)
  • CrewAI
  • LangGraph
  • Genkit
• 📑 Review key topics to understand protocol details
  • A2A and MCP
  • Agent Discovery
  • Enterprise Ready
  • Push Notifications

We welcome contributions! Please see our contributing guide to get started.
Have questions? Join our community in GitHub discussions.
Help with protocol improvement feedback, in GitHub issues.
Want to send private feedback? use this Google form

Future plans include improvements to the protocol itself and enhancements to the samples:

Protocol Enhancements:

• Agent Discovery:
  • Formalize inclusion of authorization schemes and optional credentials directly within the AgentCard.
• Agent Collaboration:
  • Investigate a QuerySkill() method for dynamically checking unsupported or unanticipated skills.
• Task Lifecycle & UX:
  • Support for dynamic UX negotiation within a task (e.g., agent adding audio/video mid-conversation).
• Client Methods & Transport:
  • Explore extending support to client-initiated methods (beyond task management).
  • Improvements to streaming reliability and push notification mechanisms.

Sample & Documentation Enhancements:

• Simplify "Hello World" examples.
• Include additional examples of agents integrated with different frameworks or showcasing specific A2A features.
• Provide more comprehensive documentation for the common client/server libraries.
• Generate human-readable HTML documentation from the JSON Schema.

A2A Protocol is an open source project run by Google LLC, under License and open to contributions from the entire community.