Advanced

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.

01 · Model access

“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.

your machinethe agent CLIclaude · codex · piits own loginnothing of ours in itthe vendor, directwhatever it is signed in withor a gatewayone URL and key, per machinethe default is the first one, and it needs nothing from you

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 --list

Choose 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 restart

The 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.

↑ Back to the topic index
02 · Rented compute

“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.

machines you owna laptopthe box in the labrenteda GPU you did not buybilled to the workspaceit joins the same network, and is reached the same way

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.

↑ Back to the topic index
03 · Autopilot

“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.

it asks a questionautopilot answersit keeps workingthe oraclea check you namenpm test, a file appearingstoppedon purposethe loop is the easy half — the ring is the half that was designed

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.

↑ Back to the topic index
04 · Issues

“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.

the backlogthe close gateit asked for the outputand would not close without itclosedwith its evidence attachedan entry anyone can pick up, and nobody can wave through

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.

↑ Back to the topic index
05 · Workflows

“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.

on a clockevery weekdayon idlenothing left to doon an issue movingready, closed, labelledon a call arrivingsomeone used a channela workflowone runwith its own log

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.

↑ Back to the topic index
06 · Safe channels

“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 workspaceand another workspaceyour data, hereit never leaveswhoever is askingthey bind their own accountthe guardian reads twicethe question going inand every draft answer coming outone person, one team, one institution — the same mechanism at every scale

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.

↑ Back to the topic index
07 · Durable URLs

“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.

tl-my-report.hypha.runthe name you hand outyesterday’s processgone, and nobody had to be toldtoday’sa different machine, eventhe link you sent last weekstill opens

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.

↑ Back to the topic index
08 · Many agents

“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.

the leadholds the planone taskone taskone taskeach in its own worktree, so they cannot overwrite each otherback to one branchwhen the checks pass

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.

↑ Back to the topic index
09 · Workspace inventory

“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.

you askin a sentencemachinesand whether they are awakeserviceswhat each one answerssessionsrunning, idle, hibernatingcreationswhat has been published

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 nothing

It 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.

↑ Back to the topic index

Where the authority is

Every command on this page is spelled as the shipped binary spells it today. When they disagree, the binary wins.

what your agent runs
myco <command> --help

That is the authority, and it is more current than this page or any document — it ships with the code rather than alongside it. myco issue --help is the clearest example: some 230 lines of measured rationale, which is where the close-gate reasoning in topic 04 comes from.

Three places the shipped help already disagrees with older documentation. (1) The deployed skill document says myco serve defaults to owner-only and needs a login; the shipped --help says the default is the link tier, an unguessable hostname that anyone holding the URL can read. The CLI is right and the difference is a security one, so topic 07 follows it. (2) The same document calls the daemon Unix-only and names a Windows archive that is no longer what the download serves — do not copy anything Windows-related out of it. (3) The peers skill says myco session messages ignores --last, --json and --raw, while myco session --help advertises them. One of the two is stale and which one is unresolved; check the behaviour before you depend on those flags.

And one thing this page deliberately does not print: the path of the credentials file. The sources disagree three ways about where it lives, and a wrong path is worse than no path because you would go and look. Ask the binary.