The workspace where your team
and AI agents work together.
You install one small program on the computers your team owns. Each one becomes a machine in your workspace. You then start AI coding agent sessions on them from a browser, and your colleagues see the same sessions. The agent works on your files, where they already are. When you need another group, you open a guarded channel to them, and their agent answers yours without your data leaving your machines.
What you need: a computer that you can install software on, and that
stays on. You also need model access for the agent. You can connect your own
Claude Code, Codex or pi account, or take model access on a Mycolab plan. (pi is the
@earendil-works/pi-coding-agent package, not the number.) Codex and pi also need
Node 20 or higher.
See it in two minutes
The film follows one researcher. She has a question. Her agent finds a group that holds the data she needs, and asks for access through a safe channel. The agent then analyses what comes back, and publishes the result for other groups to find.
Two minutes, with narration and captions. Nothing downloads until you press play.
Read what the film says
The film starts under a forest. One fungal thread is a hypha. It makes one connection. Thousands of them together are a mycelium: one body with no centre. Trees that never touch trade sugar, water and warnings through it. People call it the wood wide web. So we built one. A hypha is a connection. A mycelium is your own machines: your laptop, a GPU box, a browser. The shared ground is a workspace. Every living network has a membrane, and a membrane chooses what crosses it. Ours is a safe channel. Two researchers keep two workspaces, and a guardian on each side reads what passes between them. Neither group's data leaves its own ground. The film then puts this to work. A researcher starts a project with a question and a rough plan. Her agent looks outward for the group that holds what she needs. It searches across departments and universities. It finds one group, and it calls their agent. She gets access, and the results come back. The same agent helps her analyse them and prepare the paper. The work then fruits. A dataset, a method and a result go back into the network as one small signed publication. Other people find it immediately. Nothing moved but the knowledge.
What is Mycolab?
If you came from the film, these are the three words it uses. The mycelium is your own machines. The shared ground is a workspace. The fruiting body is the link that you send to a person. This is the same thing in plain words.
Mycolab has three parts. A machine is a computer that you own, and it runs one small program. A session is an AI agent that works on that machine, and you drive it from a browser. A workspace holds your machines and the people you let in. Your code, your files and the agent stay on your own computer.
The work goes to the data, not the other way round. Only the session crosses the mesh. Your code, your files and your processes stay on hardware that you own.
What you do with it
Three things. Everything else on this page is detail about how they work.
Every agent in one place
Mycolab keeps one list of every session on every machine your team owns. You see which agents are working and which are idle. You drive any of them from the same browser.
Nobody waits for anybody
A colleague joins the session you are running, or picks it up later. An agent in another group answers yours through a guarded channel. The work goes on while you sleep.
Your data stays where it is
The agent reads your files on your own machine. You do not upload a large dataset. It writes the code, runs it there, and gives you the charts and the numbers.
Everything in one workspace
The pieces compose: an agent can serve a report, expose a dev server, file an issue, and kick off a workflow — all from the same session.
Agent sessions
Spawn Claude (or other agents) on any machine, chat, stream their work, and drive a live terminal — from the web.
Service exposure
Publish a local HTTP server to a public https:// URL — WebSockets included, no firewall changes. One port per service. A fresh URL is minted on each publish; ask for it to be retained if the link is going somewhere permanent, like a methods section.
File serving
Share a directory — reports, dashboards, build output — as a single managed link. By default the URL itself is the credential; add --workspace, --owner or --access to require a sign-in, or --public for a named open URL. A managed mount can start on the first request and sleep when idle.
Process management
Supervise long-running processes with keep-alive and restart policy, declared in YAML and restored after a reboot.
Issues backlog
Track work as triaged issues — inline or handed to crew — with verify gates and a self-checking oracle.
Automation
GitHub-Actions-style workflows triggered by schedule, dispatch, a machine going idle, channel messages, or issue events.
Crew
A lead session farms features out to managed worktree children, then merges finished work back to main.
Self-verifying loops
Run a task until an oracle passes and an independent evaluator agrees it's genuinely done.
Managed compute & LLM
Don't want to run your own box? The console rents you a VM and inference, billed to it rather than to your own provider account. Entirely optional — Mycolab runs on your own machines with your own keys and needs none of it.
Artifacts
Versioned storage for files, datasets, and model outputs — with static-site hosting and signed tokens.
End-to-end encryption
Chat messages and terminal output in new sessions are encrypted on your own devices, and the mesh carries only ciphertext. Four things are not covered and leave your machine in the clear: metadata, uploaded files, the session summary (produced in the cloud, not locally), and — if you turn autopilot on — the one reply per round it posts to the console to decide whether to stop. Rented inference, if you use it, sees your prompts like any model vendor would: what we can and can't see.
How it works
Mycolab is built on a deliberately small contract — a client asks, the server answers, and the server can stream back. One coordinator per workspace, run by us, holding no files of yours.
A deliberately small contract. Calls go one way and end; streams come the other way and resume. Everything else — who you are, what exists, what is awake, where a call goes — is decided at the one anchor your workspace owns.
- The mesh. Each workspace gets one coordinator of its own — a Cloudflare Durable Object, meaning one small always-addressable process per workspace rather than a shared pool. It owns sign-in, service discovery, presence (whether each of your machines is actually reachable right now, decided by the server rather than claimed by the machine), call routing and ordered event streams. Your files are not in it: it routes requests to your machine and streams the answers back.
- The connector. A small daemon on your machine holds one hibernation-safe WebSocket to your workspace, registers its services, and answers calls routed to it.
- Sessions. Each agent session syncs its metadata (a Doc) and its chat/output (a Log) over the mesh, so any client gets a consistent, replayable view — and cheap re-subscribe after reconnect.
- Security. Passwordless email-code or passkey login; every call carries a workspace-scoped, server-attested identity; machines are private to your workspace by default.
Mycolab is built on Hypha Mesh
Mycolab is the product. Hypha Mesh is the network it runs on — the part that gets a browser in one country talking to a laptop in another with no ports opened and nothing in the middle holding your files. You never have to touch it, but it is why the rest of this page is possible.
Mycolab is the product; Hypha Mesh is the network it runs on. It is the part that gets a browser in one country talking to a laptop in another with no ports opened and nothing in the middle holding your files — and you never have to think about it.
Mycolab
Agent sessions, files, issues, schedules, sharing. You sign in and work.
Hypha Mesh
One outbound connection per machine, authoritative presence, name-based routing, streams and tunnels — at the edge. You run the small connector on your own machines; we run the coordinator. Neither of us runs a server for the other.
What that buys you, concretely: your machine never opens a port, your files are never copied off it, a session survives a reconnect, and the same workspace reaches a laptop, a server and a browser without you configuring any of them.
Building something of your own on the same network? The developer portal documents the protocol and the primitives.
Connect your browser
A browser joins the mesh as a node, the same way a machine does — it is an extension you install once and approve from a page. Nothing is scraped or proxied through us: the agent drives the browser you are already signed into, on your own computer.
Setup lives on the mesh, because the browser node belongs to the platform rather than to Mycolab — but Mycolab is what you will use it from.
Connect a machine to your workspace ~2 min · part of the 10-minute quickstart
Mycolab is an app you use in your browser. The only setup is telling it which computer to work on — your laptop, a desktop, a server. You do that by running four commands, once, on that computer: install it, sign in, start it, and point it at the agent you already pay for. After that the terminal is optional — sessions, files, sharing and settings all happen in the app.
On a Mac and never used a terminal? Download Mycolab for macOS, drag it to Applications and open it. It puts a small icon in your menu bar with a start/stop button and a status — no commands at all. One download, both Apple Silicon and Intel. If macOS says the app is from an unidentified developer, right-click it and choose Open once; macOS remembers.
Step 1 — install myco on that computer
Open Terminal, paste this, press Enter:
curl -fsSL https://mycolab.hypha.run/install.sh | sh
Open PowerShell (press Start, type “PowerShell”), paste this, press Enter. Works on both Intel/AMD and arm64 machines — it picks the right one for you:
irm https://mycolab.hypha.run/install.ps1 | iex
Open a terminal, paste this, press Enter:
curl -fsSL https://mycolab.hypha.run/install.sh | sh
Step 2 — sign in and start it
Same window, two more lines:
myco login myco machine start --daemon
myco login opens your browser (or shows a short code you can type on your
phone). Approve it, and the computer appears in your workspace. It keeps running in the
background, including after a restart.
One more, and that is the setup: myco install claude
(or codex, or pi) points this machine at the agent you already pay for. Then open
mycolab.hypha.run, sign in with the same account, and your machine is there
— ready to start a session. Everything from here is buttons.
mycolab.hypha.run/download/latest.json
(with a detached signature alongside it at latest.json.sig). Compare the hash of
your download against the entry for your platform:
macOS / Linux —
shasum -a 256 myco-<target>.tar.gz
Windows —
Get-FileHash .myco-x86_64-pc-windows-gnu.zip -Algorithm SHA256
Once myco is installed it checks this
for you — myco self check verifies the manifest against the release keys
baked into your binary, and myco update refuses any download whose hash does not
match. You never have to do it by hand; this is here so you can.
For developers: the myco command line — optional, nothing here is required
Everything above and below can also be driven from a terminal, and the connector
is a single self-contained binary (no Node, no npm, no Docker). Prebuilt macOS, Linux and
Windows binaries publish with each release at
https://mycolab.hypha.run/download/myco-<target>.tar.gz
(aarch64-apple-darwin, x86_64-apple-darwin,
x86_64-unknown-linux-musl, aarch64-unknown-linux-musl,
x86_64-pc-windows-gnu, aarch64-pc-windows-gnullvm), alongside
Mycolab.dmg and, for Windows, a .zip of each arch for people who
prefer clicking. The arm64 Windows triple really is gnullvm and not
gnu — there is no aarch64-pc-windows-gnu in rustc.
To install a specific build by hand instead of using the script above:
# macOS (Apple Silicon) curl -fsSL https://mycolab.hypha.run/download/myco-aarch64-apple-darwin.tar.gz | tar xz && sudo mv myco /usr/local/bin/ # Linux (x86_64) curl -fsSL https://mycolab.hypha.run/download/myco-x86_64-unknown-linux-musl.tar.gz | tar xz && sudo mv myco /usr/local/bin/ # Windows (PowerShell) — tar.exe ships with Windows 10 1803+ and 11 curl.exe -L -o myco.tar.gz https://mycolab.hypha.run/download/myco-x86_64-pc-windows-gnu.tar.gz; tar -xzf myco.tar.gz
Once a machine is connected, myco update
keeps it current on every platform, and the full command reference is further down the page.
For developers: tutorial and full command reference — optional, you never need any of this
Mycolab is driven from the app. Everything it does is also scriptable, which is useful for automation, CI, or driving a machine you cannot click on. If you just want to use Mycolab, skip this entirely.
Tutorial: from zero to a shared app
Prefer the terminal? The same things work from the CLI.
# spawn an agent in a project and give it a task (runs autonomously) myco session spawn claude -d ./my-app --message "create a hello-world Vite app and start the dev server" # list your sessions myco session list # share a folder of static output as a managed link myco serve my-report ./my-app/dist # expose a running dev server to a public https URL myco expose 5173 --name my-app # track work as an issue (self-triages: title, labels, verify) myco issue add "add unit tests for the cart module" # automate: run a check every morning myco workflow add nightly --on schedule --cron "0 9 * * *" \ --run "myco session spawn claude -d ./my-app --wait --message 'run the test suite and summarize failures'"
Command reference
myco login | Authenticate YOURSELF to Hypha Mesh (passkey or email code). No workspace needed. |
myco machine start [--daemon] | Run this computer as a machine — in this terminal, or supervised in the background. |
myco machine start --workspace <ws> | Serve another workspace you belong to, from the same computer. |
myco machine status|stop | Is it running · stop it. |
myco machine start --key <key> | Lend a computer to someone's workspace with no account at all. |
myco session spawn <agent> -d <dir> | Start an agent session in a directory. |
myco session send <id> "<msg>" | Send a message to a running session. |
myco session list | List sessions across your machines. |
myco serve <name> <dir> | Serve a directory at a managed link. The default is an unguessable hostname anyone holding it can read; --workspace/--owner/--access require a sign-in, --public gives a named open URL. |
myco expose <port> --name <n> | Publish a local HTTP server to a URL. Add --public, --workspace or --access a@x to choose who can open it. |
myco process apply <file.yaml> | Supervise a long-running process (keep-alive + restart policy). |
myco issue add "<text>" | File a tracked, auto-triaged work item. |
myco workflow add <name> --on … --run … | Create a scheduled / event-triggered automation. |
myco session messages <id> | Read a session's history from the terminal. |
myco session archive|resume <id> | Park a session keeping its conversation, and bring it back. |
myco session export <id> --out <dir> | Write a session to a portable bundle — metadata, messages and config as plain files. |
myco session import <dir> | Read a bundle into this workspace. Copy-only, idempotent, resumable. Start with --dry-run. |
myco lab | What is in this workspace — nodes, sessions, services, URLs, artifacts. (The workspace itself, not a physical laboratory.) |
myco hosts · myco ssh <host> … | Every machine you can reach, and run a command on one. |
myco nav open|read|act | Drive a connected browser — open a page, read it, click something. |
Run myco --help, or <command> --help,
for the full surface. Everything listed here is in the shipped binary — nothing here is vapour. A few individual flags are marked work-in-progress on the pages that document them in depth.
Your sessions, and what happens to them
A session is not a terminal window that dies when you close the tab. It is a durable object in your workspace, and knowing what survives what is most of knowing how to use Mycolab.
A session is not a terminal window that dies with the tab. The conversation lives in your workspace, so closing the laptop makes the session honestly offline rather than lost — and sending it a message later resumes the agent in its original directory.
- History is durable and server-side. Every message is appended to an ordered log with a gap-free sequence number. Reload the page, switch device, or come back next week — you get the same conversation, and re-subscribing after a disconnect resumes from where you were rather than refetching everything.
- The daemon restarting does not lose sessions. On start, the connector reads your workspace and re-adopts every session belonging to that machine. A session that was mid-turn when the daemon died comes back idle rather than stuck pretending to think.
- Continuing is genuine continuation. Send a message to an idle session and the agent is re-spawned against its original conversation, in its original directory — it remembers what you were doing, rather than starting over with a transcript it cannot see.
- Offline is visible, not silent. A session is shown as working only when its machine is actually reachable and the session says it is running. Close your laptop and sessions on it go offline honestly; the history stays readable from anywhere.
- You can take it with you.
myco session exportwrites a session to a directory of plain files — a metadata document and one JSON object per message. Nothing about reading your own history requires us to be running.
Good to know
The things worth knowing before you rely on something, stated plainly rather than discovered later.
- An agent session is not sandboxed. It runs as a normal process, as your user, with your files and your tools — that is the point of running it on your own machine, and it is also the risk. Treat starting a session on a machine as equivalent to handing someone a shell on it, and share machines accordingly.
- A link is a capability. By default a served mount gets an unguessable hostname and anyone
holding the URL can read it — including anyone it is forwarded to. That is the right trade for a
build report and the wrong one for anything confidential; use
--owneror--accessfor those. The hostname is not secret from DNS resolvers or TLS SNI. - Exposed services are single-port. One service, one port. There are no service groups and no health checks on this plane; a supervised process has keep-alive and a restart policy, not a readiness probe.
- Scheduled work is timed by the machine. A workflow cron is matched against the host's local clock, so a machine that is asleep at the scheduled minute does not run it then.
- Agents cost money. Sessions run real models against your own account. A loop left running is
a loop that keeps spending —
myco session listis the cheapest habit in the product.