Peer-to-Peer Secrets: How We Built Client-Side E2E Team Sync Without Server Trust

Here is a common developer anti-pattern that every engineering team has committed:

A new developer joins the team. They need the environment variables to run the application locally. A senior developer opens their password manager, copies the plaintext .env block, and pastes it into a Slack message or a secure note. The new developer copies it, pastes it into a local .env file on their disk, and starts coding.

You have just created a massive security debt:

• The credentials exist in plaintext inside your team chat history.
• They exist on a local disk in plaintext, vulnerable to local script harvesting.
• There is no cryptographic audit trail of who has access, when the keys were shared, or if they have drifted out of sync.

Traditional cloud-based team secret managers attempt to solve this by storing keys in a centralized vault. But this shifts the trust boundary to the cloud provider: you must trust the server. If the cloud provider's database is breached, or if an inside attacker compromises their server RAM, your production keys are gone.

To build a truly secure team sync infrastructure, we must adopt a Zero-Knowledge Asymmetric Sync Model.

This article deep-dives into the cryptography of AgentSecrets workspaces, explaining how we use NaCl Curve25519 asymmetric sealed boxes to synchronize environment credentials across engineering teams without the coordination server ever seeing the plaintext secrets.

The Untrusted Server Architecture

The core constraint of a zero-knowledge cloud model is simple: the server is treated as an untrusted coordinator.

The server's only job is to route encrypted blobs from Client A to Client B. It must structurally lack the cryptographic keys required to decrypt those blobs.

+--------------------------------------------------------------------------+
|                        Client-Side Device Boundary                       |
|                                                                          |
|  [Developer A]                                            [Developer B]  |
|  Plaintext Secret                                         Plaintext Secret|
|        |                                                        ^        |
|        | 1. Encrypt with B's Public Key                         |        |
|        v                                                        | 4. Decrypt with B's Private Key
|  [Encrypted Blob]                                         [Encrypted Blob]
+--------+--------------------------------------------------------+--------+
         |                                                        ^
         | 2. Push E2EE Blob                             3. Pull  |
         v                                                        |
+--------+--------------------------------------------------------+--------+
|                          Untrusted Cloud Server                          |
|                                                                          |
|  Acts as dynamic relay of ciphertext blobs. Has no private keys.         |
+--------------------------------------------------------------------------+

To achieve this, AgentSecrets utilizes client-side Asymmetric Cryptography built on the networking and cryptography library (NaCl) primitives.

Under the Hood: NaCl Curve25519 Asymmetric Sync

When a developer initializes their AgentSecrets CLI (agentsecrets init), the client dynamically generates a local Curve25519 keypair consisting of a Public Key and a Private Key:

• The Private Key never leaves the developer's local OS keychain.
• The Public Key is uploaded to the coordination server and acts as their workspace identity.

Here is the exact cryptographic workflow when Developer A invites Developer B to a shared workspace and syncs a secret:

1. The Key Exchange (DH Handshake)

Developer A fetches Developer B's public key from the coordinator server.
Developer A uses their own private key and Developer B's public key to perform a Diffie-Hellman (DH) key exchange, generating a shared symmetric Workspace Master Key unique to their interaction.

2. SealedBox Encryption

Developer A encrypts the plaintext credential (e.g., STRIPE_KEY = sk_live_51H...) client-side using NaCl's crypto_box_seal (asymmetric SealedBox primitive).

• A SealedBox is anonymous: it encrypts a payload using the recipient's public key, generating a ciphertext that can only be decrypted by the matching private key.
• The SealedBox structurally prevents even the sender from decrypting the payload once it is formed.

3. Server Relay

Developer A transmits the encrypted SealedBox blob over the network to the untrusted coordination server:

POST /v1/workspaces/sync
Payload: {"recipient": "Developer-B-ID", "ciphertext": "8f3b2a1c..."}

The server saves the encrypted blob in its database. Because the server does not possess Developer B’s private key, the ciphertext is completely unreadable to the database engine or any backend server processes.

4. Client Decryption

When Developer B runs agentsecrets secrets pull, their local CLI queries the server, downloads the SealedBox blob, and passes it to their local OS-level keychain.
Their CLI uses Developer B's private key (securely accessed from their local OS vault) to decrypt the SealedBox, recovering the plaintext credential directly into their secure local OS keychain.

No plaintext key ever touched the wire, no plaintext keys exist in the cloud database, and the server remained a purely zero-knowledge coordinator.

Managing Parity and Drift

Traditional team synchronization is plagued by Credential Drift—the situation where different environments (dev, staging, production) get out of sync because changes aren't tracked.

Because AgentSecrets treats credentials as a versioned cryptographic repository, developers can instantly run drift audits:

agentsecrets secrets diff

The CLI compares the cryptographic metadata hashes of the local OS keychain against the workspace master records stored on the server. It identifies out-of-sync references and allows the developer to sync them with a single, secure pull, completely eliminating drift without manual file swaps.

Security is Mathematical, Not Policy-Based

We cannot secure collaboration by asking team members to be careful. Human error is the primary vector for data breaches.

By enforcing client-side SealedBox encryption at the device boundary, you build a structural security perimeter that guarantees your team credentials stay safe, in-sync, and completely insulated from server breaches.

Read docs: https://agentsecrets.theseventeen.co

How does your team manage shared credentials across development and staging? Have you built E2EE synchronization pipelines before? Let's discuss in the comments below!