Remove the broker and you must reinvent four of its jobs

REST, gRPC and web sockets were born either for a human talking to a machine or for stitching together corporate microservices whose participants are known in advance. The article explains why that shape does not fit autonomous agents: an intermediate node keeps a log of requests, filters the flow and can be switched off from outside at any minute. Yet it also performed work nobody counted as work — four jobs at once. It vouched for who was on the other end. It hid the contents. It matched a customer with a supplier. It held the money and settled disputes. Dropping it means losing all four services, not merely the log.

Who is on the other end

The first duty passes to cryptography. The handshake follows the Noise_IK_25519_ChaChaPoly_SHA256 pattern from the Noise framework, and the letter I in that name is the important one: the sender must already know the static public key of the other side, and the dDOM registry is what supplies it. Ephemeral X25519 keys are mixed with the static operational keys kept in a Solana PDA, and the shared secret comes out of that mixture.

Who cannot listen in

Everything then travels under ChaCha20-Poly1305. The subtlety lies not in the cipher but in where the key is born: inside the isolated memory of the WASM sandbox, so the owner of the hardware running the agent cannot read what the agents say to each other. HKDF-SHA256 per RFC 5869, labelled IACP_SESSION_KEY_v1, yields 64 bytes that are cut in half — one key per direction. That is not tidiness for its own sake: a single key both ways would open the door to reflection attacks.

Every message is packed into a binary packet of four parts: two bytes for length, eight for the counter, sixteen for the authentication tag, and then the ciphertext itself — a semantic request in JSON-LD. The ceiling of 65,535 bytes stands against buffer overflow, and the monotonically rising counter against resending an intercepted packet. On the Solana side a session is described by six fields: initiator, responder, session key hash, counter, expiration slot and status, where a two means awaiting verification.

The third duty is matchmaking. A complex request is taken by a coordinating agent that splits it into a tree of independent subtasks; each of them then has to go to somebody, and no address book exists. In its place there is search by meaning: the vector of a subtask goes into a reworked Kademlia DHT where distance between nodes is measured not by XOR over identifiers but by the cosine between capability vectors. The walk stops when a further step no longer brings the distance closer to zero, or when an agent is found whose competence match exceeds 0.92. To keep this from turning into a scan of millions of records, VP-trees sit on top and give logarithmic search time.

When a subtask calls for reliability, the coordinator hires several independent workers and compares what they return. The outcome is a weighted sum of semantic vectors, and each participant's weight is the reputation accumulated as a share of zk-SNARK proofs successfully delivered in earlier epochs. The winning answer is the one closest by cosine to the weighted average. The survival boundary is the classic Byzantine one: with f faulty nodes the total must be at least 3f + 1.

The fourth duty — holding the money — is performed by escrow on Solana. The task budget is locked on a temporary multi-agent PDA account the moment the swarm is assembled, and the routing fee is split by the canonical 5/5/15/7/3/65 router: five per cent burns, five goes to the M. V. Galatin research fund, fifteen, seven and three reach ambassadors of the first, second and third levels, and sixty-five lands in the execution pool that pays validators of the WASM sandboxes, people who supplied cognitive imprints, and permanent storage in Arweave.

The interesting part appears with nesting. A hired worker may hire its own — a translator takes on a proofreader — and the deduction is then computed afresh from the subtask budget. In the article's own example with ten thousand dollars, the coordinator sends 6,500 into execution, 4,000 of it goes to the translator through a second escrow, and there the sequence repeats: 200 burnt, 200 to the fund, a thousand to ambassadors, and 2,600 left for the proofreader. Deflation therefore fires as many times as the task has layers.

If every subcontractor sent its own zk-SNARK to Solana, gas would eat the point of the exercise. So the coordinator folds the workers' proofs into a single aggregate one using recursive Halo2 circuits, and the contract verifies only that: by the article's estimate this cuts gas costs by 90 % and adds atomicity along the way — either the whole tree is accepted or the deal is cancelled. Underneath lies the arithmetic of folding schemes: two instances of a constraint system collapse into a linear combination with a random challenge from a Fiat-Shamir oracle, and checking the fold is equivalent to checking both steps. The on-chain part runs on the BN254 curve with an assembly verifier and a structured reference string of size 2¹⁸.

From 10 to 19 February 2026 the protocol was exercised in simulation. On the tenth a test bench went up, twenty virtual agents were switched on and a thousand semantic tunnels ran without a single encryption error. On the twelfth five proofs were folded into one: on-chain verification took 340 milliseconds and 292,000 compute units. On the fifteenth node failure was probed — six of fifteen workers were dropped at once, the coordinator returned the funds from escrow to the sender and redistributed the subtasks to reserve nodes in 5.2 seconds. On the seventeenth, 15,000 transactions went through the router at an average confirmation time of 450 milliseconds.

What follows matters as wording, and the article does not soften it: on 19 February the protocol showed stable results in a devnet simulation, and the nodes confirmed cryptographic stability within the scope of the testing plan — ahead of a possible move to the main network. Possible. None of these numbers comes from a production launch, and the article makes no claim that it does.

Even taking every devnet measurement at face value, three things remain open. First: the Noise IK pattern requires knowing the counterpart's static key in advance, so trust did not vanish, it moved into the registry. Second: the exchange of ethical policy manifests tears the tunnel down automatically, but what it checks is a declared policy rather than actual behaviour; the contract stays a declaration. Third: peer-to-peer connectivity rests on hole punching, where dDOM nodes with public addresses act as signalling coordinators. Those are the same few visible points as before — except they no longer read the traffic, they only help it start.

That is precisely the strength of the article: it never claims the broker vanished without trace. It shows something else — that the broker's work was taken apart into four pieces, each handed to a mechanism you can audit on its own: a signature, an escrow, a reputation, a proof. Auditing them will also have to happen one at a time.