Learn A2A - Pre-Requisites Skills & Environment Setup

#Introduction

Welcome to the Learn A2A series! Over the next 23 episodes, we'll break down A2A (Agent2Agent Protocol) — the open protocol from Google that now lives under the Linux Foundation — from core concepts and the Agent Card to production-grade multi-agent deployment.

Episode 0 is pure foundation. It has a single goal: making sure your environment is ready before you get hands-on. We'll verify that your runtime is installed, the official SDKs are installed, and your local environment can run at least two agents at the same time. The real technical material starts in episode 1.

#Prerequisite Skills You Should Have

#AI Agent Basics: Tool Calling & Orchestration

A2A connects agents to each other, so you first need to understand how a single agent works. Two key concepts: tool calling — the model's ability to request that external functions be executed (e.g., a database query), and orchestration — the way an agent breaks work down into steps that run sequentially or in parallel. Without this understanding, we'll get lost telling the difference between an "agent" and a "tool".

#JSON-RPC & HTTP/SSE

All A2A communication is built on JSON-RPC 2.0 — a lightweight remote procedure call protocol that doesn't depend on HTTP methods or REST conventions. You'll also need to understand SSE (Server-Sent Events), the one-way streaming channel agents use to send partial results in real time. Don't worry if you don't have the details memorized yet; episode 5 will dissect both in depth.

#TypeScript or Python

The official A2A SDKs are most mature for Python and TypeScript. Pick whichever you're most comfortable with; every example in this series uses both. This prerequisite isn't a heavy lift — you just need to be comfortable writing functions, classes, and async handlers, because that's where the SDK lives.

#OpenAPI-Style Discoverability

Before calling any API, a client needs to know what it looks like. In the REST world there's the OpenAPI spec; in the A2A world there's the Agent Card — JSON metadata that describes an agent's capabilities. This is the concept that lets one agent be "discovered" and understood by another, exactly like OpenAPI helps clients understand a REST API.

#Setting Up the Runtime: Node.js and Python

Use modern versions: Node.js 20 or later and Python 3.11 or later. Verify the versions you have installed:

node --version
python --version

Output of v20.x.x and Python 3.11.x means you're ready. To manage Node.js versions that change between projects, use nvm — the most popular Node version manager — with nvm install --lts. For Python, consider pyenv or uv so the interpreter version is locked per project.

#Installing the A2A SDKs

The official A2A ecosystem provides SDKs for Python, TypeScript, Go, Java, and .NET. We'll install the two most important ones for this series.

pip install a2a-sdk

npm install @a2a-js/sdk

Verify Python SDKVerify TypeScript SDK

import a2a
 
print(a2a.__version__)

npm ls @a2a-js/sdk

A note for teams using bun: pip install a2a-sdk runs in your Python environment; for JavaScript, the command bun add @a2a-js/sdk replaces npm install. The Go, Java, and .NET SDKs can be fetched from their respective official registries — same functionality, just a different language.

#Google ADK: Optional but Useful

ADK (Agent Development Kit) is Google's agent framework with native A2A support. It's not required, but it's very helpful because one framework can be used both to build an agent and to expose it over the A2A protocol.

pip install google-adk

We'll use ADK in episode 12 for framework integration. For now, just install it — or hold off if you want to focus on the core protocol first.

#Environment for Running Two Local Agents

The exercises in this series often require at least two agents running simultaneously: one acting as the client, one as the remote agent. Prepare a project folder structure:

mkdir -p ~/belajar-a2a/agent-a ~/belajar-a2a/agent-b
cd ~/belajar-a2a

Later, agent-a will run on port 8080 and agent-b on port 8081, both on the same machine. Since A2A runs over HTTP, you can test communication between agents with curl from this folder:

curl -s http://localhost:8080

#Verifying the Setup

Before moving on, make sure these four things work:

• node --version outputs 20 or above, and python --version 3.11 or above.
• pip show a2a-sdk displays the Python SDK metadata.
• npm ls @a2a-js/sdk shows the TypeScript SDK with no errors.
• The ~/belajar-a2a folder is ready with two agent subfolders.

If everything is green, your environment is officially ready for this series.

#Conclusion

Episode 0 is done. Here's what you should take away:

• Master the AI agent basics (tool calling, orchestration) and JSON-RPC 2.0 over HTTP/SSE.
• Understand OpenAPI-style discoverability as the foundation of the Agent Card.
• Set up Node.js 20+ and Python 3.11+ with nvm or pyenv/uv.
• Install the official a2a-sdk for Python and @a2a-js/sdk for TypeScript; ADK is optional.
• Prepare an environment that can run two local agents at the same time.

Next, in episode 1 we answer the most important question before writing any code: why was this protocol born, where does it come from, and what problem does A2A actually solve. See you there!