alto

Inspiration

Coding agents are good at a task on one machine. They are bad at working beside each other. If two agents share one computer, they overwrite files, read each other's terminals, and mix up their work. If they stay fully separate, neither knows what the other just finished.

We wanted a project where each agent gets its own computer and its own chat, and a shared notebook is the only thing they pass between them. The person stays in charge of the environment, the account, and when that notebook is on.

What it does

alto is a place to run coding agents on a real project computer.

On the website you create a project and start an environment: a Linux machine the agent can use. An environment is marked ready only after alto has connected to it and checked the workspace. From there you can open it in the desktop app.

On the desktop you pick that environment and talk to Codex in project chat. Sign in with ChatGPT happens in the app. The login opens in your browser, and the desktop connects it back to the environment. The same chat can open a terminal on that machine.

Each agent keeps its own thread. Agents do not see each other's files, terminals, or processes. If you turn on shared memory for an environment, agents there can leave short notes for the next agent. Memory is a note, not proof that the work was done. Git is how files move. If shared memory is off or unavailable, the agent still runs.

How we built it

The website is a Next.js app with sign-in, projects, and environment controls. The desktop app is Electron. Both talk to the same local API.

Environments are real machines: a local Docker sandbox today, with remote hosts as an optional path. Each one gets its own SSH identity. The desktop reaches it with a key created on that device. Codex runs inside the environment over that connection.

ChatGPT sign-in was the awkward part. Codex waits for the login callback on the environment, but the browser is on your Mac. The desktop opens a tunnel between the two, then opens the ChatGPT page. The website can start the same flow by handing the desktop the environment and the session.

Shared memory uses Backboard, one notebook per project. The key stays on the server. A switch on each environment decides whether agents there read and write notes.

Challenges we ran into

A saved address is not a running computer, and a heartbeat is not proof that Codex did the work. We kept the product from showing "ready" until the connection and workspace were actually checked.

ChatGPT's login callback assumes the browser and the agent share one machine. They do not. The tunnel has to exist before the browser opens, and it has to close if sign-in is cancelled or the connection drops.

Shared memory was easy to overbuild. If the notebook is down, the agent should still get the original message. Notes also cannot contain secrets, and one environment's switch cannot turn memory on for every other environment.

Splitting the product between a website and a desktop app meant every flow had to have one owner. The website prepares the environment. The desktop owns the chat, the terminal, and the browser login.

Accomplishments that we're proud of

You can start an environment on the website, open it in the desktop app, sign in with ChatGPT, and chat with Codex on that machine.

The same sign-in works from the website and from project chat, because both use the desktop tunnel instead of inventing a second login.

Shared memory is optional per environment. Agents on that environment can hand each other notes, and a failure in the notebook does not stop the agent.

The app starts empty. There is no fake project, fake agent activity, or sample result pretending the work already happened.

What we learned

Collaboration and isolation need different channels. Sharing a filesystem feels simpler until two agents step on each other. A notebook is a better handoff than a shared terminal.

Remote computers break assumptions that local tools take for granted. "Localhost" is a different machine once the agent is in a sandbox.

Optional features should fail quietly. Sign-in, chat, and the environment have to keep working when a notebook or a remote host is missing.

What's next for alto

Let agents on one environment actually use the shared notebook to pick up each other's tasks, with each agent still on its own computer.

Connect the agent's file and command tools to that environment, so a note can point at work the agent can open and run.

Keep published results alive after the environment stops, so a site or API does not disappear when the agent is done.

Built With

• amazon-web-services
• backboard
• betterauth
• chatgpt
• docker
• electron
• next.js
• node.js
• openai
• playwright
• radixui
• react
• sqlite
• ssh
• terraform
• typescript
• vite
• xterm.js