Every machine within reach. Only as far as you allow.

Your laptop, phone, home computer and servers usually can’t reach each other directly. To get into one, you set up a VPN or tunnel, copy keys onto every machine, and keep the work alive with tools like tmux. That’s a lot of separate setup just to get in.

Once you’re in, you can do everything on that machine: every file, every port, every command. You can’t say “only this folder” or “never read this file.” So you either hand over the whole machine or nothing.

There’s no programmatic way to do this reliably. All of that setup expects a person at a keyboard who can copy a key, reconnect, or pick up a dropped session. A program can’t do those steps reliably on its own. That includes an agent running for hours, an app, or a chat bot. No program has a dependable way to say “connect me to that machine, with only this access, and keep the connection going.”

We’re building a programmatic layer that allows applications and developers to securely access machines, run sessions, and execute jobs with fine-grained permissions, regardless of where those machines are located.

For example, a Slack bot built using this layer could be configured to let you ask an AI agent to debug an issue directly on a remote machine and report its findings back in Slack, without giving it access to sensitive files like .env. Another example could be a mobile app that uses the GPU on your desktop to run computations.

To make this possible, we handle the underlying complexity of networking, including connecting machines behind NATs, maintaining stable connections when networks change, and enforcing access permissions.

But the infrastructure is only the foundation. A big part of our vision is to build genuinely useful products on top of this layer ourselves, while also making it available to other developers so they can build entirely new applications and use cases.

Ultimately, we want to create both great products and a strong developer community around this infrastructure, where the possibilities extend far beyond what we build ourselves.

Our team has spent the last three years building low-level blockchain infrastructure: the clients that actually run blockchains.

Blockchains are some of the most resilient distributed systems ever built. Thousands of machines that don’t know or trust each other find one another, stay in sync and keep running, all in the open. Working on them taught us that a network open to anyone can still be safe, if it has good answers to a few questions: how machines find each other, how they talk securely, and what each one is allowed to do.

Those are the same questions at the heart of remote access, and we think the answers belong in everyday computing, not just in blockchains. We also want this ourselves: we work across more machines every year, and we’d like our own agents to work on them without handing over the keys to everything.