To call another A2A agent, first obtain its Agent Card, choose an interface and operation the card supports, satisfy its declared authentication requirements, and send a message using an A2A client. Then handle the result as either a final response or, when both sides support it, a stream of task events.
How the A2A call works
A2A is a protocol for communication between agents built with different frameworks. A caller does not need access to the remote agent’s internal memory, tools, or implementation. Instead, the remote server publishes an Agent Card that describes what it is, what it can do, how to contact it, and what requirements apply to interaction.
As an Amazon Associate I earn from qualifying purchases.
The call is a sequence of decisions rather than a single “send prompt” operation:
- Discover: retrieve the remote server’s Agent Card, commonly from its well-known path.
- Inspect: read its skills, supported interfaces, capabilities, input and output modes, and security requirements.
- Configure: select a compatible interface and obtain any required credentials.
- Send: construct a message and submit it using the client SDK or protocol interface.
- Handle: consume the final task or message, or process events if using streaming.
The released A2A specification page identifies version 1.0.0 as the latest released specification. SDKs and tutorials may evolve on their own schedules, so use documentation that matches the SDK version installed in your project rather than combining examples from different protocol releases.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
Think of the card as the boundary contract between two independently built services. The caller uses that contract to choose a destination and communicate in a supported way; it does not need to know how the remote agent reasons or which framework powers it. Conversely, the card is not a promise that every request will succeed. The server still has to be reachable, the request must fit the advertised interaction, and any access requirements must be met.
What the Agent Card tells the caller
An Agent Card is metadata published by a particular A2A server, not a general-purpose directory of every available agent. The specification says, “A2A Servers MUST make an Agent Card available.” A caller can use the card to decide whether that server is an appropriate destination before sending work.
Check the card for the information that affects your request:
Recommended Free Tools
- Identity and description: establish which service you found and what it claims to do.
- Skills: identify the advertised tasks that are relevant to your request. Match the request to a skill instead of assuming the agent handles arbitrary prompts.
- Interfaces and endpoints: choose an interface the server actually advertises. A card may describe more than one supported interface.
- Input and output modes: check whether the formats you plan to send and receive are supported.
- Capabilities: check whether the operation you want, including streaming when relevant, is supported.
- Security requirements: inspect the advertised security schemes before attempting a call.
These fields work together. A relevant skill is not enough if the advertised interface is incompatible with your client, and a compatible interface is not enough if the request uses an unsupported input mode. Before sending, make a simple match: intended task to skill, request format to input mode, expected result to output mode, and call style to capability. Then check whether the security information calls for credentials.
Discovery can happen through the standard well-known URI /.well-known/agent-card.json, a preconfigured card URL or card content, or a registry/catalog that provides discovery information. The well-known path is a default convention, not a guarantee that every deployment uses that exact location; a server may publish its card at a custom path.
A registry or catalog can help a caller find card information, but it does not turn each Agent Card into a universal index. The card describes a particular server. Once a card is obtained, use its own endpoint and interface information rather than assuming that the registry itself is the agent endpoint.
Build and expose the remote agent
If you are building both sides, the server must provide a reachable A2A endpoint and publish a card that accurately describes it. The official Python server tutorial composes a request handler, an agent executor, and a task store, then attaches Agent Card and JSON-RPC routes to a Starlette application served with Uvicorn. The route factories also support REST, and A2A materials include examples for frameworks beyond Starlette.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Describe the service honestly
Define the server’s skills and card details to match what the executor can actually do. Advertise supported input and output modes, capabilities, and interface information that a caller can use to make a sound choice. If authentication is required, expose the relevant security scheme in the card. A mismatch—such as claiming a skill that the executor does not perform—may lead a caller to send a request your server cannot handle.
Before exposing the card, review it from the perspective of a client that has never seen your implementation. Can that client identify the service, find a relevant skill, see which interface and endpoint to use, determine acceptable input and output modes, and learn whether streaming or authentication applies? If any of those details are missing or inaccurate, the caller may make an invalid choice even if the agent itself works when invoked directly.
Attach the protocol routes
The server tutorial’s composition has three functional pieces: the executor performs the agent’s work, the request handler connects protocol requests to that executor and task storage, and the application exposes the card and protocol endpoints. The tutorial uses a JSON-RPC route; its route factories can also support REST. Select and advertise an interface consistently so clients know how to communicate with the service.
The pieces have distinct responsibilities. The executor is the agent-specific part; the handler is the bridge from incoming A2A requests to that executor and the task store; the web application makes the discovery and protocol routes available. Keeping those roles clear helps when diagnosing a failure: a card-route problem is different from a request that reaches the handler but cannot be completed by the executor.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →The tutorial’s sample endpoint is http://127.0.0.1:9999. That address is loopback-only: it is useful for a local example, but another machine cannot use it as a public service address. For a remote caller, deploy the server at a network-reachable endpoint and make sure the Agent Card advertises the reachable address, not a developer’s local loopback URL.
The example’s address and framework choices are tutorial implementation details, not requirements of the A2A discovery flow. A2A does not require Starlette, Uvicorn, or a particular hosting platform. It does require that clients be able to obtain the server’s card and reach the advertised interface they select.
Discover the remote card from Python
The Python client tutorial uses an asynchronous HTTP client and A2ACardResolver. Pass the remote server’s base URL to the resolver, call get_agent_card(), then use the returned card to initialize the A2A client. The resolver uses /.well-known/agent-card.json by default; when a server publishes its card elsewhere, provide the custom card path supported by the resolver.
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
- Start with the base URL. Use the server’s externally reachable base URL, not a local-only address unless the client runs on the same machine.
- Resolve the card. Have
A2ACardResolverretrieve the card at the default or configured path. - Review before calling. Confirm the card identifies the expected service, includes a relevant skill, and advertises a compatible interface, modes, capabilities, and security scheme.
- Initialize the client from the card. Use the card and a
ClientConfigto create the client for the selected interaction mode.
The resolver step and client step answer different questions. Resolution asks, “What does this server advertise?” Client initialization uses that information to prepare a caller for a particular supported interaction. Keep the base URL, retrieved card, and chosen configuration associated with the same remote agent; using a card from one service to configure a call to another would undermine the discovery contract.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsDo not treat successful card retrieval as proof that a later call will succeed. Discovery verifies that the card can be fetched; it does not itself prove that credentials are valid, that a particular operation is available, or that the remote agent can complete a request.
Send a message and handle the response
For the basic Python flow, create a text message with the user role using new_text_message, wrap it in a SendMessageRequest, and asynchronously iterate over client.send_message(request). In the tutorial’s non-streaming example, the iteration yields a final Task or Message.
- Choose the request content. Make sure the message format is permitted by the card’s input modes and that its purpose fits an advertised skill.
- Create the user-role message. Use the SDK’s message helper rather than assuming that an arbitrary framework’s prompt object is already an A2A message.
- Wrap it as a send request. Submit the request through the client created from the remote card and the selected configuration.
- Consume the asynchronous result. Iterate the result instead of assuming that the SDK call immediately returns a plain text string.
- Handle the returned type. The final result may be a Task or a Message. Treat it according to its actual type and status rather than assuming every successful response is only text.
The message helper, request wrapper, client, and asynchronous iterator are all part of the tutorial’s client flow. Preserve that order in your application: construct a protocol message, put it into the send request, invoke the client, and consume what the asynchronous operation yields. The tutorial does not describe the return as an immediate plain string, so code that assumes one risks discarding the task or message structure it actually receives.
The protocol separates the caller from the remote agent’s internal implementation. Your application should therefore make its own decisions about how to present the returned result, what to persist, and what to do when the response represents work that has not reached a final state.
For example, a user-facing application can decide whether to show a completed result immediately, display progress events as they arrive, or retain task information for its own workflow. Those are caller-side product decisions; the A2A client’s job in this flow is to send the message and make the response or events available for the application to process.
Choose between a single response and streaming
The Python tutorial demonstrates a non-streaming request and a streaming configuration using ClientConfig(streaming=True). Streaming is useful when intermediate progress or artifacts matter, but it is not guaranteed: the remote server must advertise and support the necessary capability, and the client must be configured to consume the stream.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
| Consideration | Single response | Streaming |
|---|---|---|
| Client configuration | Configure for non-streaming. | Enable streaming in the client configuration. |
| What the caller handles | A final Task or Message from the tutorial’s example. | Events or chunks as they arrive; the tutorial’s example includes task, status, artifact, and completion events. |
| Useful when | Intermediate updates do not help the caller or user. | Work may take time, or the interface needs to show progress or artifacts as they become available. |
| What must align | The selected interface and operation must be supported by the remote agent. | The client must enable streaming and the remote agent must support the required streaming capability. |
| Lifecycle | Follow the SDK client’s normal lifecycle. | Explicitly close the streaming client after consuming the stream. |
Choose based on what the caller needs, not on the novelty of streaming. If the user only needs the completed result and intermediate updates add no value, a single-response interaction avoids adding a stream consumer to the application. If progress or artifacts matter while work is under way, streaming can expose those events as they arrive, provided the remote agent supports it.
Streaming changes how the caller consumes the result. Rather than treating the operation as one completed answer, process each event as it arrives and distinguish task, status, artifact, and completion events. The Python tutorial’s example shows those event categories; the application can decide what each means for its own interface. After consuming the stream, close the streaming client as the tutorial does.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Do not switch on streaming merely because the client library supports it. If the card does not advertise the capability, or the server does not implement it, use a supported non-streaming operation or choose another agent. When streaming is used, design the consumer to process events as events—not as if each chunk were the completed answer.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Meet the server’s authentication requirements
Some agents may allow unauthenticated access; others may require credentials. Read the card’s security schemes rather than assuming either condition or hard-coding one authentication method for all agents. The A2A overview’s OpenID Connect example uses the authorization and token URLs advertised by the agent to obtain a token.
- Inspect the security information in the Agent Card.
- Determine which declared scheme applies to the interface and operation you intend to use.
- Obtain credentials through the mechanism specified by that scheme. For an OpenID Connect flow, use the advertised authorization and token URLs as appropriate to the client’s role.
- Attach the resulting authentication material to the request using the client’s supported configuration.
- If the call is rejected, check that the credentials are valid for the destination and that the advertised scheme was implemented correctly.
Do not copy an authorization or token URL from a different agent, and do not infer that card discovery grants permission to call the service. Discovery describes how to interact; the server still enforces its access requirements.
Authentication is part of client preparation, not a substitute for discovery. The card tells the caller which security scheme the server advertises; the caller must then use the mechanism for that scheme and the destination in question. In the OpenID Connect example, the advertised authorization and token URLs are relevant to obtaining a token. Do not assume that every A2A service uses OpenID Connect, or that credentials for one service are appropriate for another.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Troubleshoot common failures
- The card cannot be fetched: check the base URL, network reachability, and whether the server uses the default well-known path or a custom card path. A loopback address such as
127.0.0.1works only from the same host. - The card is found but the request is rejected: re-check the selected interface, operation, input mode, and authentication requirements against the card.
- The client expects streaming but receives no stream: verify that the server advertises streaming support and that the client is configured for it. Use non-streaming if streaming is unavailable.
- The result is not plain text: inspect whether the SDK returned a Task or Message and process its status or content accordingly.
- The client is left open after a stream: close the streaming client after consumption, as shown in the Python tutorial’s lifecycle.
- A tutorial example does not match the installed SDK: check the SDK’s current documentation and its corresponding tutorial version. The official quickstart introduction is for v0.3.0 and is historical tutorial context, not a reason to mix its API with a current client example.
It helps to locate the failure in the sequence. If the card cannot be retrieved, investigate the address, path, and reachability before changing message construction. If retrieval works but the call fails, compare the request with the card’s interface, modes, capabilities, and security schemes. If the call yields data in an unexpected form, inspect whether it is a Task, Message, or streamed event before treating it as a display problem.
Deploying the caller and server
A2A defines agent communication, not a single hosting platform. The core flow—publish a card, discover it, choose a compatible operation, authenticate when required, and exchange a message—does not require Cloud Run or any other specific deployment environment. The official tutorial index includes an ADK agent deployment tutorial for Cloud Run, and also lists samples in Java, JavaScript, and C#/.NET in addition to Python.
Choose a deployment approach based on your service’s operational requirements. Whichever environment you use, the caller must be able to reach the endpoint advertised by the card, and the card must describe the service’s actual interfaces and requirements. Test the full path from the caller’s environment: card retrieval, authentication, request submission, and response handling.
For a local tutorial, the sample’s 127.0.0.1 endpoint makes it possible to run and test the server on the same host. For a deployed caller and server, replace that local-only address with the endpoint clients can actually reach and ensure the card reflects it. Hosting changes where the service runs; it does not change the discovery sequence or remove the need to select a supported interface and satisfy the card’s requirements.
Frequently asked questions
How do I discover another A2A agent?
Retrieve the Agent Card published by the server. The default well-known URI is /.well-known/agent-card.json; the Python tutorial uses A2ACardResolver with the server’s base URL. If the server publishes the card at a custom path, configure that path. A preconfigured card URL or content, or a registry/catalog that supplies discovery information, are also possible discovery routes.
Does every A2A server use the same endpoint path?
No. /.well-known/agent-card.json is the default discovery path, but a server may publish its card at a custom path. Use the path that applies to the service you are calling.
Does retrieving an Agent Card mean I can call the agent?
No. Retrieval gives you the server’s advertised metadata. You still need to select a supported interface and operation, use compatible input and output modes, and meet any advertised authentication requirements. The remote service must also be reachable and able to handle the request.
Should I use a single response or streaming?
Use a single response when intermediate updates do not help. Choose streaming when progress or artifacts are useful while work is in progress, but only if the remote agent supports the relevant capability and the client is configured for streaming. Close the streaming client after consuming events.
What does the Python client return?
The tutorial’s non-streaming example asynchronously iterates over client.send_message(request) and yields a final Task or Message. Do not assume it immediately returns plain text. In streaming mode, the tutorial shows task, status, artifact, and completion events.
Does A2A require Python, Starlette, or Cloud Run?
No. The Python tutorials illustrate one implementation, using Starlette and Uvicorn for the server. The official materials include examples in Java, JavaScript, and C#/.NET, and Cloud Run appears as a deployment tutorial option. A2A is the agent communication protocol; hosting and framework choices are separate decisions.
The Bottom Line
Build the call around the Agent Card: discover it, verify the destination’s skills, interface, modes, capabilities, and security requirements, then send a correctly constructed message. Use a single response or streaming according to the remote agent’s advertised support, and test the entire path from the caller’s environment.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
