Documentation
A lightweight, production-ready framework for agent-to-agent communication, built on and extending Google's A2A protocol.
Welcome to the Protolink documentation.
This site provides an overview of the framework, its concepts, and how to use it in your projects.
Current release: 0.6.4 (PyPI | Changelog).
What is Protolink?
ProtoLink is a lightweight, production-ready Python framework for building distributed multi-agent systems where AI agents communicate directly with each other.
Each ProtoLink agent is a self-contained runtime that can embed an LLM, manage execution context, expose and consume tools (native or via MCP), and coordinate with other agents over a unified transport layer.
ProtoLink implements and extends Google's Agent-to-Agent (A2A) specification for agent identity, capability declaration, and discovery, while going beyond A2A by enabling true agent-to-agent collaboration.
The framework emphasizes minimal boilerplate, explicit control, and production-readiness, making it suitable for both research and real-world systems.
Find Your Path
ProtoLink Project Map
An interactive index of the framework: A2A primitives, agent runtime, transports, registry discovery, state, tools, LLMs, and operational surfaces.
Where each part of the project fits
Agent as the autonomous runtime unit
The Agent facade owns identity, lifecycle, execution, policy, tools, optional LLMs, state access, and peer communication through client/server boundaries.
protolink.agentsprotolink.coreprotolink.models- Owns AgentCard identity and advertised capabilities
- Starts and stops the embedded server runtime
- Executes tasks, tool calls, inference, cancellation, and reports
- Coordinates registry registration and discovery through RegistryClient
- Does not implement protocols directly
- Does not require a specific LLM provider
- Does not force a storage backend
Follow one system from identity to operations
Why Protolink?
The landscape of AI agents is shifting, from monolithic scripts driven by a single model, towards Multi-Agent Systems where specialized, autonomous agents collaborate to solve complex problems.
But today's frameworks often trap you in a walled garden:
- 🔒 Locked into a specific LLM (OpenAI, Anthropic, etc.)
- 🔒 Locked into a specific Transport for communication
- 🔒 Locked into specific Tooling schemes
- 🔒 Agents are just functions, not independent entities
Protolink breaks free from this model.
In Protolink, an Agent is an autonomous, centralized object that serves as the core unit of your system. It is designed to be fully modular so you can plug in any LLM, tools, transport, storage, telemetry, and authentication stack you need.
Care only about the logic. Leave the communication, agent lifecycle, inference, tooling, authentication, memory, and logging to Protolink.
Unlike the base A2A specifications, Protolink enables more open and flexible communication: agents can call another agent's LLM for reasoning, invoke its tools directly, or define custom communication schemes. This creates a flexible mesh where specialized agents leverage each other's native capabilities without rigid orchestration bottlenecks.
Protolink vs Google A2A 💡
ProtoLink implements Google’s A2A protocol at the wire level, while providing a higher-level agent runtime that unifies client, server, transport, tools, and LLMs into a single composable abstraction the Agent.
| Concept | Google A2A | ProtoLink |
|---|---|---|
| Agent | Protocol-level concept | Runtime object |
| Transport | External server concern | Agent-owned |
| Client | Separate | Built-in |
| LLM | Out of scope | First-class |
| Tools | Out of scope | Native + MCP |
| UX | Enterprise infra | Developer-first |
What you can do with Protolink
-
Build agents quickly
See Getting Started and Agents for the core concepts and basic setup. -
Choose your transport
Explore Transports to switch between HTTP, SSE JSON-RPC streaming, WebSocket, and in-process runtime transports with minimal code changes. -
Plug in LLMs & tools
Use LLMs and Tools to wire in language models and both native & MCP tools as agent modules.
Key ideas
- Unified Agent model: a single autonomous
AI Agentinstance handles both client and server responsibilities, incorporating LLMs and tools. - Flexible transports: HTTP, SSE JSON-RPC streaming, WebSocket, and in-process runtime transports. The
grpctype is reserved for future support, but it is not registered in the default transport factory yet. - LLM‑ready architecture: first‑class integration with API, local, and server‑hosted LLMs.
- Tools as modules: native Python tools and MCP tools plugged directly into agents. Import tools from thousands of existing MCP servers instantly.
- Resilience by design: by decoupling the Brain (LLM) from the Body (Agent), you are immune to provider outages or pricing changes.
- State Management: Unified persistence for conversation history, tool state, task metadata, and flow context across multiple sessions.
- Developer freedom: the pluggable architecture means you own your stack. No vendor lock-in, no framework constraints, just clean, composable components.
Use this documentation to:
- Install Protolink and run your first agent.
- Understand how agents, transports, LLMs, and tools fit together.
- Explore practical examples you can adapt to your own systems.
Protolink is open source under the MIT license. Contributions are welcome – see the repository’s Contributing section on GitHub.