The thinking behind Envmesh.

A development secret spends its whole life on the developer’s machines: created there, used there, leaked there. The risks that matter — a plaintext file readable by every process, copies that outlive their purpose, an agent quietly reading a production key — are all local. Envmesh starts from that observation and treats the device as the unit of trust.

Teams have a second problem: many people sharing one source of truth. Servers solve that well, which is why cloud managers are the right call for teams — the landscape page covers when. Envmesh is built for the first problem, and macOS already ships the primitives it needs: Keychain, code signing, and local networking.

Tailscale demonstrated that people will happily operate real infrastructure when it feels like none: every device gets its own identity, you approve a device once, and the mesh forms itself. The lesson is that device identity plus an explicit approval ceremony can replace an account as the root of trust.

Envmesh applies that shape to secrets and takes it one step further: there is no coordination server at all. Devices pair directly and sync ciphertext over whatever private route connects them — the same network, a tailnet, a VPN — and the vendor never enters the data path, because there is no vendor in the system to begin with.

The local-first movement made a precise argument: software should keep your data on your device, work offline, and treat synchronization as a capability rather than a dependency. Most local-first work concerns documents and collaboration, where the hard part is merging concurrent edits.

Secrets are the ideal local-first payload. The data is tiny, changes rarely, and needs no merge algorithm — while the cost of placing it with the wrong custodian is the highest of any data you hold. Envmesh is local-first software in the strictest sense: the store works with zero network, forever.

Syncthing has proven for over a decade that peer-to-peer sync with explicit device approval works for ordinary people, at scale, with no accounts. Envmesh narrows that proven model to a harder payload: everything on the wire is ciphertext, and approving a device is treated as the security-critical moment it actually is — done once, in person, and revocable afterward.

macOS Keychain established the pattern on the desktop: a system store that applications must ask, item by item, with the user able to see and revoke each grant. The principle underneath is capability-based security — possession of a running process should confer no rights by itself.

Envmesh extends the grant model along the dimensions developers actually work in: project, environment, command, and session. The consequential addition is the last one. A coding agent is a separate principal with its own session, its own scope, and its own audit log — because an agent holding your shell’s ambient access is the largest new secret risk since the plaintext file.

tool run -- command has become the shared grammar of this category, and for good reason: injecting values at process start, into one process, leaves nothing exported in your shell and nothing new on disk. Envmesh keeps the gesture exactly as developers know it, and keeps .env as an import and export surface so that adopting Envmesh — or leaving it — is one command, not a migration.