AgentConnect is six SDKs for one protocol, on four release trains

Five questions the protocol set out to answer

ANP, the Agent Network Protocol, is a stack rather than a single specification, and this repository is its SDK. It organises itself around five questions, each with a concrete artefact behind it.

Who is speaking is answered with DID WBA identities, DID documents, HTTP Message Signatures and verifier helpers. What an agent can do is answered with Agent Description documents, OpenRPC interface documents and JSON-RPC endpoints. Whether to trust an object or a request is answered with W3C Data Integrity proofs, Appendix-B object proofs, IM and origin proofs, and DID-WBA binding proofs. How humans and agents find each other is answered by WNS handle validation, resolution and binding verification. How to talk privately is answered by direct and group end-to-end encryption building blocks that ANP-compatible clients and services are expected to reuse.

That split is the design decision. Each layer can be adopted without the next, so a team can start with signed HTTP requests and add group messaging later without changing its identity model.

One repository, six SDKs, four release trains

The Python package is named `anp`, and the same repository carries Go, Rust, Dart, TypeScript and Java implementations. They are not released together, which is the first thing to understand before planning around them.

Registry status was checked on 2026-08-18. Python, Go, Rust and TypeScript are published at `0.9.3`. Dart is published separately at `0.8.7`, and so is TypeScript in practice: the table marks both as versioned outside the current Python, Go and Rust release helper. Java is the outlier, published nowhere: it is usable from a local Maven build at version `1.0.0`, and the project states plainly that its Maven Central metadata check returned not found.

So there are four trains rather than one. The release helper coordinates Python, Rust and Go under a single version, and the Go module adds a wrinkle of its own with tags in the form `golang/vX.Y.Z`. Dart and TypeScript move when their own maintainers move them, and Java moves when someone builds it locally.

The tree is at 1.0.4rc1 while the registries serve 0.9.3

The build metadata in `pyproject.toml` declares version `1.0.4rc1`, a release candidate a full major version ahead of the `0.9.3` the README reports for PyPI. Read together, those two facts say the repository is tracking toward 1.0 while the installable package is still on the 0.9 line, so what you get from `pip install anp` is not what you would read in the checkout.

The dependency list explains part of the gap, and constrains your environment at the same time:

[project]
name = "anp"
version = "1.0.4rc1"
requires-python = ">=3.8"

dependencies = [
    "ecdsa>=0.19.0",
    "cryptography>=43.0.3",
    "asn1crypto>=1.5.1",
    "websockets>=13.1",
    "pydantic>=2.9.2,<3.0.0",
    "pyjwt>=2.9.0",
]

A floor of Python 3.8 alongside `cryptography` 43 is generous in one direction and narrow in the other: the declared floor is far older than the cryptography release it requires, so the real constraint is the dependency, not the metadata. The package builds with hatchling, and the source distribution ships the `anp/` package with both READMEs, `LICENSE` and `NOTICE` while excluding the in-package markdown, caches and tests.

binding_generation is required per language, not per package version

The most revealing corner of the documentation is the handle continuity matrix. ANP-04 WNS 1.1 makes `binding_generation` a required security field, and the project is explicit that support for the stricter contract is introduced language by language rather than implied by a shared package version. A version number therefore tells you nothing about whether your SDK handles the stricter rule.

The matrix is not uniform. Python has it implemented and has no OpenMLS surface, so the handle rebind primitives do not apply. Rust has it implemented and its existing `group.e2ee.add` and `group.e2ee.remove` typed primitives accept the same `GroupStateRef`. Go implements it but offers a contract and provider surface with no in-process OpenMLS status API, and its status is recorded as shared conformance vectors passing. Dart and TypeScript implement it without group encryption surfaces. Java is not applicable twice over, since it has neither a WNS surface nor group E2EE, so there is no API to synchronise.

The release tooling makes the same point in prose: a release claim has to distinguish WNS generation conformance from Rust's in-process OpenMLS rebind and status capabilities. Conformance across languages is real here, but it is conformance to shared test vectors, not to a single implementation.

Python is where the agent-building code lives

The Python SDK is the one with an agent-building layer on top of the protocol: OpenANP for quickly building and calling ANP agents, plus authentication, proof, WNS, AP2, crawler and E2EE modules. The other languages cover the protocol core, with Go and Rust taking core identity, proof and WNS functionality plus selected E2EE surfaces, and Dart narrowing further to identity, proof and WNS helpers.

If Python is your target, the entry points are concrete. `examples/python/did_wba_examples/e1_authenticate_and_verify.py` creates an e1 DID and runs complete authentication, `DID_WBA_AUTH_GUIDE.en.md` covers adding DID WBA authentication to an HTTP service, and `examples/python/anp_crawler_examples/` covers calling or crawling another ANP agent. A DID Web SDK guide sits at `docs/did-web-sdk.md`.

One configuration detail to expect: the bundled `.env.example` contains nothing but commented-out Azure OpenAI settings, so anything involving an LLM is configured separately from the protocol itself. The package description does mention automatic protocol negotiation based on LLMs, and the `api` extra exists to pull that path's dependencies.

Five one-line installs, and one that needs a checkout

Everything except Java is a single command, taken from the SDK table:

pip install "anp[api]"
go get github.com/agent-network-protocol/anp/golang@latest
cargo add anp
dart pub add anp
npm install @awiki/anp-typescript-sdk
cd java && mvn clean install -DskipTests

The Java line is in the same list and is not the same kind of operation: it builds and installs into your local Maven repository from a checkout, skipping tests, because there is no published artefact to consume. Plan for a Maven build step in your build pipeline if you take the Java SDK, and for a version you control rather than one a registry hands you.

The Python extras are worth understanding before you install. Plain `pip install anp` gives you the protocol core, while `pip install "anp[api]"` adds the FastAPI, Uvicorn and OpenAI dependencies that the OpenANP agent-building path needs. Installing the extras into an application that already pins FastAPI is where dependency conflicts will surface.

What this repository does not settle

Three boundaries are visible from the outside. First, the specification is not here. The project URLs point the SDK at the AgentConnect repository and the documentation at AgentNetworkProtocol, so the protocol definition and this SDK are maintained as separate artefacts and can disagree. Second, group encryption is uneven: Rust has in-process OpenMLS primitives, Go has a contract surface without a status API, and three languages have no group surface at all, so an encrypted group feature is not portable across the SDKs today. Third, the Java SDK has no registry presence, which makes it the one component with no upgrade path.

On upkeep the signals are healthy rather than settled. The last push was on 2026-10-01, releases include a dated `release-20260912` alongside versioned SDK tags such as `v0.8.8`, and the licence is Apache-2.0 with a `NOTICE` file at the root. The package lists a single author, changshan, which for a protocol project means the bus factor is the thing to weigh before building a dependency chain on it.

Editorial conclusion

AgentConnect fits a team building agents that have to be findable and verifiable by strangers, since DID WBA identity, Agent Description documents and WNS handles are the parts you would otherwise design twice. It does not fit a Python-only project that just needs signed HTTP, and adopting it means accepting a protocol surface owned by another repository plus a version story where the source tree sits ahead of what the registries serve. Verify first which registry versions you actually get, whether binding_generation support in your language of choice is implemented or merely planned, and whether the Java artefact you need will come from a local Maven build rather than a registry.

Frequently asked questions

Official sources

1. agent-network-protocol/anp on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases