MIT-licensed Rust framework for multi-agent systems in Rust

The a2a-rs project is an MIT-licensed Rust framework for the protocol, the bridges, and the plumbing a multi-agent system needs, with every piece of infrastructure behind a port a developer can replace. emillindfors.github.io's report presents version 0.10 on crates.io as up to spec with A2A 1.0: messages, tasks, artifacts, push notifications, extended agent cards, card signatures, and every task state. Divergences are opt-in, backward-compatible, and documented in the spec compliance notes. One agent serves ConnectRPC, JSON-RPC 2.0, and HTTP+JSON.

The piece is for Rust developers who embed an agent in a commercial product, fork the crates, or build an agent platform, since every crate is MIT licensed and no adapter is load-bearing. It covers A2A v1.0 operations, ConnectRPC, JSON-RPC 2.0, HTTP+JSON, Responder, a2acli, and crates a2a-mcp, a2a-llm, a2a-ap2, and a2a-web-client.

MIT-licensed Rust framework for multi-agent: what actually changed

The protocol crate stands alone, and other crates extend it. Each is published independently to crates.io and docs.rs. a2a-rs holds domain types, ports, the ConnectRPC, JSON-RPC 2.0, and HTTP+JSON transports, auth, and in-memory and SQLx storage. a2acli negotiates its transport from the agent card, ships prebuilt binaries for Linux, macOS, and Windows, and doubles as a cross-SDK interop harness. a2a-mcp bridges A2A and MCP in both directions. a2a-llm offers provider-neutral chat completions for OpenAI-compatible endpoints and Gemini, plus decision models that answer typed questions with probabilities instead of text. a2a-ap2 implements the Agent Payments Protocol.

SendMessage and SendStreamingMessage either block until the task settles or return immediately. GetTask and ListTasks filter by state and context and are paged. SubscribeToTask adds gap-free resume between a2a-rs peers, beside CancelTask. Push notification configs support create, get, list, and delete, with webhook delivery and retries. GetExtendedAgentCard adds agent card signatures. Feature flags are jsonrpc-server and jsonrpc-client for the spec's JSON-RPC 2.0 and HTTP+JSON bindings, auth for JWT, OAuth2, and OpenID Connect, sqlite and postgres for SQLx task storage, and full for all of the above.

MIT-licensed Rust framework for multi-agent: how it works

An agent is one trait, Responder: given the message and the task, it returns a reply and the ending state. Shout uses async_trait on a2a_rs::adapter::business::Responder with A2AError, Message, Part, Role, Task, and TaskState. The comment says to reply in capitals and finish the task. respond joins get_text parts and uppercases them. Message::builder sets Role::Agent, Part::text, message_id from uuid::Uuid::new_v4, task_id from task.id, and context_id from the message. The returned pair is that reply and TaskState::Completed. ResponderMessageHandler creates the task, keeps its history, and announces every transition to stream subscribers and push webhooks.

An agent that acknowledges now and finishes later implements AsyncMessageHandler instead. Storage, streaming, and push delivery are ports with in-memory adapters. InMemoryTaskStorage::new, InMemoryStreamingHandler::new, storage.push_notifier, and Shout go into ResponderMessageHandler::new. SimpleAgentInfo::new takes shout and 127.0.0.1:8080. with_description sets "Repeats what you say, louder". with_streaming turns streaming on. ConnectRpcAdapter::new takes the handler, storage, and the card, then with_streaming_handler attaches streaming. HttpServer::new starts on 127.0.0.1:8080. The Cargo.toml dependency is a2a-rs version 0.10 with features http-server and http-client. examples/quickstart.rs runs via cargo run -p a2a-rs --example quickstart --features http-server,http-client.

MIT-licensed Rust framework for multi-agent: why it matters now

SQLite or PostgreSQL storage, JWT, OAuth2, and OpenID Connect auth, plus retries and tracing, each sits behind a feature flag, so it is compiled only if selected. Transports decode a request and hand it to TaskService, which only talks to ports. The developer implements the message handler. Every other edge has an in-tree adapter to keep or replace. The transport edges are ConnectRPC, JSON-RPC 2.0, HTTP+JSON, an auth guard, and SSE. The ports are AsyncMessageHandler, AsyncTaskLifecycle, AsyncTaskQuery, AsyncStreamingHandler, AsyncEventLog, AsyncNotificationManager, AsyncPushNotifier, AsyncConversationStore, AsyncContextStateStore, and Authenticator.

Adapters behind those ports are in-memory storage, SQLite, PostgreSQL, streaming fan-out, a webhook sender, JWT, OAuth2, and OIDC. No adapter is load-bearing, so nothing locks a product in. Every crate is MIT licensed, so a team can embed it in a commercial product, fork it, or build an agent platform on top. Agent cards publish what a peer can do. Contexts carry a conversation across tasks. Input-required hand-offs, streams that resume without gaps, and push webhooks sit on that same multi-agent surface.

MIT-licensed Rust framework for multi-agent: who is affected

Imports are HttpClient, Message, Transport, and SendCompletion. HttpClient::new points at 127.0.0.1:8080. Message::user_text carries hello, agent. The client comment states that WhenSettled is the A2A default: the server answers once the task has finished, so the reply is already in task.history. The call is send_task_message(None, the message, None, None, SendCompletion::WhenSettled). Output shows task 7725e89c-… is TASK_STATE_COMPLETED, from task.id and task.status.state. Commands are cargo install a2acli and export A2A_URL for 127.0.0.1:8080. a2acli card asks what the agent can do. a2acli send hello, agent sends and waits for the reply.

MIT-licensed Rust framework for multi-agent: what to watch

JSON-RPC 2.0, a spec binding, is checked for server and client. HTTP+JSON, a spec binding, is checked for server and unchecked for client. ConnectRPC, the a2a-rs default, is checked for both server and client. gRPC, a spec binding, is unchecked for server and client. Clients negotiate from the agent card's supported interfaces, choosing ConnectRPC when the agent offers it and JSON-RPC otherwise. Those bindings are crossed against the official A2A Rust SDK in both directions, using that SDK's CLI and server over JSON-RPC and HTTP+JSON.

Quickstart storage is only the in-memory adapter, not SQLite or PostgreSQL. The sqlite, postgres, and auth flags bring in SQLite, PostgreSQL, JWT, OAuth2, and OpenID Connect. Security schemes are HTTP bearer, API key, OAuth2, OpenID Connect, and mTLS. Unchecked cells are the HTTP+JSON client and both sides of gRPC. Divergences stay opt-in, backward-compatible, and written in the spec compliance notes. The page says issues and pull requests are welcome. The crates.io line is a2a-rs 0.10 with features http-server and http-client.