What the INK Protocol Is
INK stands for Inter-agent Networking Kernel. It is an open protocol for verifiable agent-to-agent messaging: AI agents that act on behalf of people exchange typed, signed messages so they can discover each other, negotiate intent and record verifiable receipts without a shared platform or a central broker.
Every INK message is an Ed25519-signed envelope over RFC 8785 (JCS) canonical bytes. Deployments that opt into third-party auditability submit append-only audit events to a Merkle transparency log attested by a witness. The protocol is transport-agnostic. The reference implementation is the TypeScript library @adastracomputing/ink, with source at github.com/Ad-Astra-Computing/ink. It is not the only implementation: the same repository carries an independent Go implementation that both signs and verifies, runs the same conformance corpus and is exercised against the TypeScript side in a containerized live exchange on every push.
The entity map
INK is the open protocol specified on this site. @adastracomputing/ink is the reference library that implements it. Ad Astra Computing, Inc. stewards the specification and publishes the library. tulpa.network is Ad Astra’s personal-agent product and the first deployment built on INK. The protocol and the library are deliberately kept free of product code so other operators can adopt INK without inheriting any one product’s surface.
Other projects named Ink
The name Ink is shared by several unrelated projects. None of them is this protocol.
Ink Protocol (XNK) was a decentralized reputation and payment token for peer-to-peer marketplaces, built on Ethereum by the team behind Listia. Its token sale ended in early 2018. It is unrelated to INK.
Ink is also the name of an Ethereum Layer 2 chain from Kraken, built on the OP Stack and live since December 2024. That is a blockchain network and is unrelated to INK.
ink! is a Rust-based smart-contract language from Parity for building contracts in the Polkadot ecosystem. It is a programming language and is unrelated to INK.
Ink is also a React library for building command-line interfaces with components. That is a terminal UI toolkit and is unrelated to INK.
If you arrived here looking for any of the above, this is not that. INK here is the Inter-agent Networking Kernel, an agent-to-agent messaging protocol. When citing this protocol, “INK protocol” or “Inter-agent Networking Kernel” disambiguates; a bare “Ink” rarely does.
How INK relates to nearby protocols
MCP (Model Context Protocol) connects one model to its own tools and data sources; the trust boundary is inside a single deployment. INK connects one person’s agent to another person’s agent across organizations, where the counterparty is untrusted by default; the trust boundary is the wire. The two compose: a service can expose an MCP server for its tools and an INK endpoint for its agent’s inbound contact.
A2A-style agent-to-agent frameworks and INK address the same layer with a different center of gravity. INK’s base contract is small and cryptographic first: every envelope is signed over canonical bytes, replay is bounded, discovery resolves to verifiable key material and a mandatory conformance corpus pins accept-and-reject behavior across independent implementations. Orchestration, task lifecycle and UI negotiation are out of scope; those belong above the kernel, which is what the K in the name means.
DIDComm shares the signed-messages-between-DIDs shape. INK differs by pinning one concrete profile instead of a family of options: one signature suite, one canonicalization with a strict number and string-safety profile, one discovery surface, typed intent envelopes with a frozen grammar and a cross-implementation conformance corpus. An implementer gets a single answer to every wire question, checkable against fixed vectors.
Email is the closest ancestor in spirit. SMTP let any server message any other without a central gatekeeper, and accountability arrived later as layered evidence. INK keeps the permissionless shape and moves verification into the protocol from the start: sender authentication is a signature over the message bytes rather than a bolted-on header standard, and receipts make delivery disputes checkable.
INK and agent identity products
An INK identity is key-derived and self-certifying: the identifier embeds the founding public key, minting one requires no account with anyone and no provider can revoke it. Products that issue agents a hosted identity, such as an inbox, a phone number or an address book entry behind an API, are services; the identity lives with the provider and ends with the account. The two models can coexist, since a hosted agent can hold an INK keypair, but they answer different questions. INK’s answer, stated normatively in the identity model: an agent identifier proves possession and continuity of a key, nothing more, and anything stronger is evidence a receiver asks for explicitly.
Provenance
The protocol began in March 2026 as the tulpa.network wire protocol, and the wire still shows that origin: ink/0.1 retains the tulpa/sign signature domain, and receivers dual-accept the legacy network.tulpa.* message namespace alongside network.ink.*. It was named INK and moved into the open at github.com/Ad-Astra-Computing/ink, with a public commit history since May 2026, npm releases under @adastracomputing/ink since 2026-05-27 and dual MIT OR Apache-2.0 licensing. It is stewarded by Ad Astra Computing under a written governance document. Implementer contact: ink@tulpa.network.