Connecting Agents with Cryptography - Liam Horne

Open original

As AI agents handle sensitive personal data across different networks, they'll need ways to cooperate on shared problems without exposing that information. This piece walks through cryptographic techniques like secure multiparty computation and homomorphic encryption that let agents answer narrow questions together before deciding whether to share more.

  • Agents can use MPC and FHE to check mutual interest (free calendar slots, matching errors, salary ranges) by computing on encrypted or secret-shared data, revealing only yes/no answers rather than raw information.
  • A hybrid approach combines MPC and FHE so agents create a shared encryption key while keeping secret key shares, preventing even the computing server from decrypting results without both parties' consent.
  • At scale, millions of agents paying for private computations could generate thousands of payments per second, making fast stablecoin networks and state channels economically viable for settling these micro-transactions.

The author imagines a future where personal AI agents handle sensitive information—calendars, messages, documents, code—and work together across different locations (your laptop, cloud services, corporate networks). The key problem: how do agents discover they're solving the same problem and decide what to share before committing to collaboration? Three cryptographic techniques can help. Secure multiparty computation (MPC) splits private inputs into random pieces distributed among participants, who then calculate answers without anyone holding enough pieces to reconstruct others' data. Fully homomorphic encryption (FHE) lets a cloud service compute directly on encrypted inputs without ever reading them, though it's slower and more expensive. Trusted execution environments (TEE) use protected hardware, but require trusting the manufacturer. The author focuses on the cryptographic approaches because they keep data private even from the hardware itself. The author walks through concrete examples where this matters. Two friends could compare calendars to find a dinner time without exposing their full schedules. Colleagues could check if their salaries are within $10,000 of each other without revealing actual numbers. Developers encountering the same bug could privately match library versions and error codes to find each other. A simple salary comparison illustrates how it works: with MPC, agents calculate the gap using encrypted shares and reveal only yes or no; with FHE, a compiler turns the math into operations on encrypted numbers, so the server never sees the actual values. The two techniques can combine—participants use MPC to create a shared encryption key while keeping pieces of the decryption key separate, and the server returns a cryptographic proof that it answered the right question before either agent helps decrypt the result. The economics matter too. Cryptographic computation is expensive, so agents would pay services to run these checks—potentially a tenth of a cent per comparison. A million agents checking once every ten minutes would mean roughly 1,700 payments per second. That demand justifies fast, low-cost payment networks like Tempo, where agents from different cloud providers can settle up without their providers building custom billing integrations. As volumes grow into millions of payments per second, state channels become useful—agents exchange payment updates offchain and settle totals later, similar to how Web3Torrent let peers pay each other tiny amounts for file pieces. The vision is agents finding collaborators as easily as they find information today, forming groups around problems, sharing only what's necessary, and paying each other to help solve them.

Ask about this article