Mycolab, organised by what you are trying to do.
This page is organised by aim rather than by feature, because the hard part is never the command — it is knowing which of nine mechanisms is the one you want, what it refuses to do, and roughly what to ask for. Each topic says why it is built that way, then gives you a sentence to say. The commands are here too, one click down, because that is your agent’s job rather than yours.
Pick your aim
Every topic below is a question somebody actually asked. Jump to yours — each one opens with why the mechanism is shaped the way it is, then the sentence that triggers it.
Model access
Point a machine at your own subscription, a gateway, or a proxy — and know which of the three agent runtimes honours which setting.
02Rented compute
Use somebody else’s inference instead of your own, and what we can and cannot yet promise about it.
03Autopilot
Let an agent keep going without you — and, much more importantly, have it halt when the work is finished or wedged.
04Issues
A backlog that outlives the conversation, with a close that runs a command instead of accepting a paragraph.
05Workflows
Something that happens on a clock, on idle, on an issue moving, or on a channel call.
06Safe channels
A door into your workspace for somebody outside it, with a guardian reading every reply before it reaches the caller.
07Durable URLs
Five access tiers, and how to keep a published link working after you republish behind it.
08Many agents
Several sessions on one codebase, two messaging planes, and the measured reason the default is not to reply.
09Workspace inventory
What exists in here, which workspace a command will hit, and how organisations widen the view.
“I want to control which model my agents use.”
Mycolab does not reimplement an agent. It drives the vendor’s own CLI as a long-lived subprocess, which is why model access is a credential on the machine rather than a setting in a web form — and why the default is simply to use whatever that CLI is already signed in with.
Mycolab does not reimplement an agent. It drives the vendor’s own CLI as a long-lived subprocess — which is exactly why the model is a credential sitting on that machine, and why the default is to use whatever that CLI is already signed in with.
In the app. A machine has its own settings page, and connecting an account has a screen of its own.
or sayuse my own Claude subscription on this machine, not the shared gateway
Your agent sets the machine’s auth mode and restarts the daemon — the step people forget, which presents as a wrong key.
Install a runtime
what your agent runs
# runtimes: claude · codex · pi
myco install claude
myco install --listChoose where the model lives
what your agent runs
myco machine auth
myco machine auth use-login
myco machine auth set <URL> <KEY>
myco machine auth use-hypha-proxy <URL>
myco machine restartThe last line is not optional. myco machine auth mutations
write the credential and do not restart the daemon, so until you run
myco machine restart the new setting is stored and not used — which presents exactly
like a wrong key. The other spelling trap is in set: the base URL must not end in
/v1.
The three modes, in one line each. use-login (the default) reads the
credentials the harness wrote itself — for Claude Code, its own login with your subscription or an
ANTHROPIC_API_KEY in the environment. set points the machine at any
Anthropic-compatible gateway. use-hypha-proxy routes through the Hypha LLM proxy using
HYPHA_TOKEN; the URL is required and has no default, so it is whichever endpoint you were
given. Run myco machine auth with no arguments to see the current mode, base URL and a
redacted key.
The settings are not shared evenly across the three runtimes. The same
ANTHROPIC_* pair serves claude and pi, and codex has
its own credential under myco machine codex-auth. But pi ignores
ANTHROPIC_BASE_URL — measured, not assumed; it reads a providers file that
references $ANTHROPIC_API_KEY. So a gateway you set for Claude Code is not in force for pi,
and the key is.
Versions and prerequisites. Exactly three runtimes are supported:
claude (native installer, minimum 2.1.294), codex
(npm i -g @openai/codex, minimum 0.161.0) and pi
(npm i -g @earendil-works/pi-coding-agent, minimum 1.1.0). The two npm ones need
node 20 or newer and are refused with an explanation on older node. myco install
needs no root: it lands in the connector’s own bin directory, which is already first
on every session’s PATH. There is no myco llm verb — that spelling is an unknown
command.
“I want to rent compute and inference instead of bringing my own.”
There is a second, entirely optional half of the platform: the Hypha Console, which provides compute and LLM access for a Mycolab workspace. Everything on the rest of this page works without it.
Entirely optional, and the same shape. Everything else on this page works without it; what renting buys you is a machine on the network that you did not have to acquire, not a different way of working.
In the app. Add provider stands a rented machine up and joins it to this workspace.
or sayI do not want to set up a GPU for this — rent the compute
A machine you did not have to buy, billed to the workspace, joining the same network as the rest.
console.hypha.run is the front door. Signed out, it says
what it is for and nothing more; the proxy base URLs it publishes in production take the shape
/llm/anthropic (optionally with an account segment) and /llm/openai, which is
the shape a gateway setting in topic 01 would point at.
What we will not claim here. Whether a brand-new account gets any model access by default, and what the sign-up path through the console looks like, are both behind its login and were not observed. So this page promises no included allowance and describes no click-path. If you want rented inference, sign in and read what the console offers you; if you want to bring your own, topic 01 is the whole story and the console is not involved.
One hard dependency worth knowing about. Autopilot’s decision plane runs on
the console — see topic 03 — and its smart mode needs an OpenAI key configured
there. That is the one place where an otherwise local feature reaches out.
“I want an agent to keep working without me.”
Autopilot answers an agent’s questions and keeps it moving toward a goal. The whole design effort went into the opposite property — making it stop — because the two bad shapes here are a loop grinding on long after the work is done, and a session stalled on a human who is not there. As the design puts it: a doom loop with an auto-answerer attached is invisible, which is worse than the stall it replaced.
The stopping condition is the feature. A loop that grinds on past the finish is invisible in a way the stall it replaced never was, so give autopilot something mechanical to check and it will stop as soon as that check passes.
In the app. Turn autopilot on for a session from the composer, and stop it the same way.
or saykeep going until the test suite passes, and stop as soon as it does
The stopping condition is the important half: give it something mechanical to check and it will not grind on past the finish.
what your agent runs
myco session autopilot <id> --goal "make the test suite pass" --oracle "npm test" myco session autopilot <id> --mode smart --max 20 --dry-run --json # off. there is no --off. myco session abort <id> myco session abort <id> --lock # latching e-stop myco session unlock <id>
The oracle outranks the model. --oracle <cmd> is a shell command
that decides the question the model would otherwise guess at. If it passes, the loop stops without
calling a model at all. If it fails, it vetoes the model’s claim to be done. If it
will not run, the loop stops. Give it one whenever the goal has a mechanical answer — it is
both cheaper and stricter than any amount of judgement.
The connector holds no policy. It names no model, carries no threshold and keeps
no rules. Each round it waits for the turn to genuinely end (an unknown state does not count
as idle), reads the last reply, and posts it with the goal to the console’s decision endpoint, where
a pure function ranks the rules in a fixed order: a human-only question first, then done-is-done, then
no-progress terminates. That is deliberate — a policy that needs changing should not need a new
daemon on every machine. Health check:
curl -s https://console.hypha.run/steer/v1/health.
Nobody is asked by default. --human is opt-in and defaults to
nobody, so an overnight run, a scheduled job and a delegated child all keep flying rather than
waiting on a person who is asleep. When a turn leaves the gate exactly where it found it, the wait
doubles from 15 seconds up to 10 minutes rather than spinning. And smart mode never
silently downgrades to the cheaper ralph mode — the plain one, which simply
repeats the goal every turn with no judgement about whether it is converging — if its key is
missing it says so, because
a silent downgrade triggered by an upstream error is the worst available shape.
Two things this is not. myco session abort is the off switch
— there is no --off flag, and --lock latches it until
myco session unlock, which is what you want when something must stay stopped. And the
self-verifying loop is a different mechanism: a per-session engine whose state file under the
project’s .mycolab directory is the single source of truth for phase, iteration and
budget. There is no myco loop command — a loop is something the user begins from
the app, not a CLI verb. The in-app autopilot switch and the composer’s slash command are reported
by the shipped help and the skill, but were not observed for this page.
“I want to track work that outlives this conversation.”
An issue is plain markdown in the project’s own .mycolab/issues
directory, so the backlog travels with the folder and shows up in a git diff like everything else. The
distinctive part is not the list — it is what a close has to survive.
A backlog is cheap; a close gate is the point. An entry can require an expected output or a command that must pass, so “done” is something the gate checked rather than something somebody asserted.
In the app. The issue list files, assigns, comments and closes.
or sayfile that as an issue, and do not let it close until the tests pass
A tracked item with its verification command attached, so closing it has to survive a shell rather than a claim.
what your agent runs
myco issue add "the export drops the last row" --verify-cmd "npm test" --scope project myco issue list | show <id> | ready | work | triage myco issue assign <id> --to <session> myco issue comment <id> --dispatch myco issue close <id> --branch main --evidence "npm test" --expect-exit 0 myco issue pending
The close gate is the feature. Closing runs the issue’s stored
--verify-cmd, refuses while the fix’s branch still holds commits the base has never
seen, and refuses prose as evidence before the shell has seen it. You can pin the result exactly
with --expect-exit, --expect-output, --expect-contains and
--expect-absent. The reason is measured: one issue in this repo was offered for closure four
or five times and refuted in prose each time — and prose is something no gate can read.
Give it the verify command at add time. That is the moment you know
what would prove the fix; by the time somebody is closing it, the knowledge has usually left the room. An
issue with no stored command has nothing to run at the gate.
myco issue pending is an oracle. It exits 0 when nothing is
actionable, which makes it exactly the kind of mechanical answer topic 03’s
--oracle wants — an autopilot run can grind the backlog down and halt by itself when it
is empty. And before writing anything, add compares your title and body against every open
issue and names up to three similar ones, so a duplicate is caught at the only moment it is cheap.
“I want something to happen on a schedule, or on an event.”
A workflow is a YAML file in the project’s .mycolab/workflows directory,
shaped like a GitHub Actions workflow, where each step is an ordinary shell command. Same reasoning as
the issues above: it lives in the folder, so it is reviewable, diffable and travels with the work.
Four different kinds of thing, one place they land. A workflow does not care which of them woke it — which is what makes “do this every morning” and “do this when somebody asks” the same feature.
Say something likerun this every night at two, and message me if it breaks
A workflow in the project, on a schedule, whose failures reach you instead of sitting in a log.
what your agent runs
myco workflow add nightly --on schedule --cron "0 2 * * *" --run "npm test" myco workflow list | show <name> | run <name> | enable <name> | disable <name> myco workflow guide
Five kinds of trigger. schedule (cron), dispatch (you or
an agent fires it), idle (the session has nothing to do), issue — which
fires on an issue becoming ready, being closed, or being labelled — and channel, for an
inbound call from outside the workspace (topic 06). The idle and issue triggers
are the two worth reaching for first: between them they turn the backlog in topic 04 into something that
drains itself.
myco workflow guide before you write YAML by hand. The file format is
the authority on itself, and run will execute a workflow once on demand so you can see what
it does before a cron expression decides when.
“I want to give someone outside my workspace a door in.”
Data is isolated by regulation, by policy and by ordinary distrust — and an agent works best with the widest context, so the value sits exactly where the walls are. The conventional answer, copying the data into a shared lake, fails on the same walls that created the problem. Mycolab is already the other shape: the data never moves, and the agent sits on top of it on the owner’s machine. What was missing is a door.
A channel runs between any two workspaces, and a workspace can be one person. Two colleagues who keep separate data, two groups in one department, two labs, two universities — this is one mechanism for cross-user, cross-workspace work, not a federation feature you need an institution on the other end to use.
A channel is a door, not a membership. It runs between any two workspaces — and a workspace can be one person, so you do not need an institution on the other end for this to be worth doing.
In the app. New channel composes one with a form, and the channel list shows every door you have: who may call it, what it may do, and every call it took.
or saylet the group down the hall ask this one question — aggregates only, nothing else
A named door with its own limits and a record of every call — and no key, because every caller signs in as themselves. It is not a login either: a door is not a membership.
what your agent runs
myco channel create "karolinska trial read" --description "aggregates only" myco channel guardian <ch> --on --contract "no individual records; aggregates only" myco channel sandbox <ch> --on --image <ref> --data ./trial-ro --network proxy myco sandbox doctor # before you hand out the link myco channel share <ch> --access view --expires 24h myco channel requests | approve <id> | deny <id> myco channel callers | block | calls | thread | reply | files
Four axes, each individually legal and jointly dangerous — which is exactly
why they are flags with prose attached rather than a settings form.
Admission: every caller binds their own Mycolab account, so no key is ever issued, the link is
safe to post, and there is nothing to rotate.
Contract: your prose is compiled once, at creation into a frozen, hashed set of atomic
questions, so what is being enforced cannot drift under you.
Sandbox: a container that cannot read your files, your credentials or your daemon.
Egress: --network proxy reaches the model endpoint and nothing else;
none reaches nothing.
The guardian reads both directions. A pre phase runs over the inbound
message and a post phase over each draft reply before it reaches the caller, carrying
what has already been released in its state — which is the only way to catch a mosaic leak, where
no single answer crosses the line and the fifth one does. Three bands: allow, ask you (the reply
is held for you), deny. An admission request nobody answers waits forever rather than defaulting to
yes.
âš But do not read that as a sandbox guarantee. This page used to say here that the call is refused if a sandbox is unavailable — which cannot be true while the per-caller container wiring is unfinished, as the paragraph below says it is. There is no mechanism today that confines an outside caller’s session, so nothing can refuse on its absence. The guardian and the limits are real; the confinement is not yet.
Three things to know before you post a link. (1) Run
myco sandbox doctor first if you intend to use --sandbox at all — it reports
whether this machine can run one, and
the time to find that out is before a stranger is holding the URL. (2) The guardian is a filter and a
holding gate, not a proof: its accuracy on held-out contracts is modest and calibration work is not
done, so scope a channel to what you would accept being released. (3) The container, the attestation and
the egress sidecar all ship, but the per-caller channel wiring does not — do not yet plan on
each caller’s session running in its own container.
The label is positional. myco channel create --name foo is
silently ignored; the label is the first positional argument, as in the example above. Also: a
channel created under the older store never appears in the current UI, because both stores coexist.
“I want a published URL to keep working.”
Three verbs that are not synonyms: myco serve publishes a directory,
myco expose publishes a port, and myco tunnel is a third thing that
manages URL retention and publishes nothing at all. Everything is outbound: the machine dials its
own tunnel agent and a public request is framed back down that socket, so no port is ever opened.
The name outlives the process. That is the difference between a URL you can put in a paper and one you have to apologise for — retention is a property of the name, not of whatever happens to be serving it this morning.
Say something likekeep this link alive — I have put it in the methods section
The hostname is retained, so re-running the analysis updates what is behind the link instead of minting a new one.
Publish
what your agent runs
myco serve my-report ./dist --public myco expose 5173 --name my-app --public myco serve list | info | remove <name>
Keep the URL
what your agent runs
myco tunnel list myco tunnel retain <tunnel-id> myco tunnel release
Five access tiers, one parser, enforced twice (at the edge and re-checked by the
daemon). --public is open to anyone at a named URL. The default is the link
tier: an unguessable 88-bit hostname, where the URL itself is the whole credential. Then
--workspace, --owner, and --access a@x,b@y for named people. A
mount is served at the root of its own hostname, so an app’s absolute paths work with no
rebuild.
retain is run once, and AFTER you publish. A named URL is minted fresh
on every publish, so a link you handed out dies the moment the mount behind it is taken down —
retention is the fix for exactly that. An unlisted URL cannot be retained and the attempt is
refused, because in that tier the label is the capability: pinning it would be pinning the secret.
Two caveats that belong next to the commands. (1) An unguessable hostname is not a confidential one — it is visible to DNS resolvers and in the TLS handshake. It is the right trade for a build report and the wrong one for anything sensitive. (2) A mount created before the access gate shipped keeps an ungated edge until it is re-added, so an old mount is not quietly covered by a tier you set later.
Beyond a static folder. myco serve apply <yaml> declares process
mounts, and those are the only mounts that read the identity headers the edge adds for a signed-in
visitor. myco process apply ./web.yaml with wake_on_request: true lets a mount
sleep until somebody knocks. And a session’s own tree can serve directly — an
src/index.ts written as a Worker-style default export with a fetch handler is
enough, with no build and no deploy, through myco apps publish. Remote targeting of
myco serve with -m/--machine is marked work-in-progress; run it on the machine
holding the files.
“I want several agents working on one codebase.”
A workspace holds as many sessions as you like, each spawned into its own working directory. That directory is the unit of isolation, and it matters more than it sounds: everything else in a workspace is shared — nodes, services, URLs, artifacts, pins — while files on disk belong to one machine. Two agents in one folder share a tree; two agents in two checkouts do not.
Parallel work needs isolation more than it needs parallelism. Each child gets its own worktree, which is what lets three of them edit the same repository at once without the second one landing on top of the first.
Say something likesplit this into three pieces and give each one its own agent
A lead and three children, each in an isolated copy of the work, converging when they are done.
what your agent runs
myco session spawn claude -d ./feature-a --message "port the exporter" myco session spawn claude -d ./feature-b --message "add the regression test" myco session whoami --all myco session list | attach <id|handle> | restart | hibernate | archive | resume
Crew: one child per feature, each on its own branch
Two sessions in one folder share a working tree, so the second one to save wins. Crew is the shape that avoids it: a lead farms a feature out to a managed child, and the child gets its own git worktree and branch off the lead’s project root. When it is finished the lead merges the branch back. The children are real sessions — you can watch and talk to them like any other.
what your agent runs
# the lead spawns a fenced child myco feature start "port the exporter to the new API" \ --area "src/export/*,test/export/*" --name "exporter port" --oracle "npm test" # what is running, and what each child is allowed to touch myco feature list --fences # the child reports in; the lead pulls the work back myco feature report "the exporter is ported; the regression test is still red" myco feature merge <child-id> --push
--area is the whole idea, and it is REQUIRED for a worktree child. It is
the list of files that child may commit, and it is enforced by a pre-commit hook rather than by the
brief — so a partition between six children holds without anyone having to remember who was given
what. The reason it cannot be optional is that the fence is a property of the set: one child
allowed to touch anything voids the partition for every sibling, and until two of them commit the same
file nothing distinguishes that from a fenced crew. To say “this one really may touch
anything”, pass --area "*" — the capability is identical and the decision
becomes something a later reader can see. Inspect the hook any time with myco feature guard.
Delete a worktree with myco feature reap, never with
rm -rf. A worktree gets its dependencies from symlinks into the main checkout, and
rm -rf some/worktree/node_modules/ — with that trailing slash — walks
through the link and empties the main one, breaking every session on the box at once. The tell is
inverted, too: the symlink survives, so the obvious check afterwards says nothing was removed.
reap is dry by default, lists every symlink pointing out of the tree before it touches
anything, and refuses the main checkout. Its scope is git worktree list, so it covers a
worktree wherever it lives.
what your agent runs
myco feature reap # dry run: what would go, how big, and every symlink myco feature reap --all --yes # every ORPHANED shell a merge left behind myco feature reap <name> --yes # one, live or orphaned
Two messaging planes, and they are not interchangeable.
myco session send <id> "…" arrives as a user turn — it is run now,
or queued to the peer’s next idle under one idempotency key, and the exit tells you which of the two
happened. myco session inbox is an attributed, replyable mailbox read on the next
turn. Use --subject for a one-line headline and --body-file - for anything long
enough that quoting it would be a hazard.
what your agent runs
myco session send <id> "the base moved; rebase before you push" --subject "rebase" myco session inbox list --unread myco session inbox send <target> "<body>" --urgency urgent myco session inbox reply <message-id> "…" myco session inbox read | peek <id> myco session inbox clear --message <id>
The default is not to reply, and this is measured. Five sessions sharing one folder over 14 hours exchanged 122 messages received against 754 sent — roughly 455,000 tokens of agent-to-agent text, for a handful of decisions that actually needed two parties. The inverse failure is just as real: one mailbox held 15 messages, all 15 unread, and none still useful by the time they were read. So the inbox is built to be cheap to ignore and expensive to spam — send to unblock work, not to acknowledge it, and treat silence as a complete response.
Urgency is the sender’s own declaration, and it is load-bearing. Only
--urgency urgent may skip the idle wait and wake a hibernated session. When a mailbox has to
be truncated, ranking keeps urgent first, then a merge request or a blocker, then ordinary mail, then
anything marked as needing no action — and an entry that has been ignored starts ringing on its own
account, sorting above newer mail rather than ageing out of view.
“I want to know what is in my workspace.”
A workspace is the tenant boundary and the one shared context: every session, machine and browser signed in to it sees the same nodes, services, URLs, artifacts and pins. One Cloudflare Durable Object at the edge is the anchor for all of it. Files are the deliberate exception — they belong to a single machine, which is why sharing a file means pinning it or serving it.
One network, not four lists. Machines, sessions, services and creations are the same fabric seen from four angles, which is why the way to find out what you have is to ask rather than to open four screens.
In the app. Open Machines: every computer you have connected, which are online right now, and what is running on each.
The live roster — every machine, every session, who owns it, and whether it is actually answering.
What is here
what your agent runs
myco hosts myco session whoami --all myco list myco tunnel list myco lab myco lab pin ./notes.md --as notes myco lab get <ref>
Which workspace, and who is in it
what your agent runs
myco workspaces myco workspace current | info | list myco workspace create | select | use | attach | detach myco workspace members myco workspace prompt set myco org list | show
Running something on a machine you are not sitting at
myco hosts lists every machine in the workspace you can reach, and prints a
ready-to-run myco ssh line on each row — so the next command is a copy away rather than
something to compose. myco ssh then runs one command there over the mesh, with no sshd and
no open port: the machine is already holding an outbound connection, and this rides it.
what your agent runs
myco hosts
myco ssh <host> "uname -a"
myco ssh <host> --cwd /srv/app "git pull && npm ci"
myco ssh <host> --probe # can it exec at all? runs nothingIt composes like a local command, which is the point. Output streams as it happens,
piped stdin is delivered (up to 1 MiB), and the remote exit code becomes this command’s exit
code — so myco ssh host "npm test" && echo ok means what it looks like it
means. --max-secs asks the host to kill a command and also stops this side waiting for it.
Retries are safe only if you say so. --idempotency-key makes a repeat
replay the recorded output instead of running again, and the host reserves the key before it
spawns anything — so that holds even for a command that reached the machine and ran. Without the
flag a fresh key is generated per invocation, which protects the command’s own internal retries but
not a second invocation by you. The ledger never expires; the replayable output is kept 24h,
after which a repeat returns the recorded exit code alone.
The precedence chain decides which workspace a command hits, in this order:
-w on the command line, then $MYCOLAB_WORKSPACE, then whatever
myco workspace select last chose, then the machine’s default attachment. Worth reading
twice before debugging a command that seems to be looking at the wrong place.
use and attach are different operations. A machine
credential is scoped to exactly one workspace, so use re-enrols the machine while
attach gets it a second credential — which is how one computer serves several
workspaces at once rather than being handed back and forth.
myco workspace prompt set writes a system prompt that every session in that workspace
inherits, which is the cheapest place to put a standing instruction.
Organisations widen the view without merging anything. One organisation holds many
workspaces; a user may belong to several organisations; a workspace belongs to at most one. It is
enforced as a capability that grants organisation-wide reads across member workspaces, and an
answer that could only be assembled partially says so rather than looking complete.
myco manage survey | route | broadcast | changes is the fleet-wide view.
Two limits of the CLI here. myco workspace list needs a user
session: an agent or machine token authorises exactly one workspace and cannot enumerate the others, so
the command is not broken when it comes back thin. And organisation membership changes are not in the
CLI at all — they need a passkey step-up, so they live in the app under Settings, then
Organizations.