Skip to content

The nt terminal client: install, TUI, serve and CI

Install the nt terminal client, sign in, run sessions in the TUI, run a server for scripts and other machines, use it in CI, and read the full command and flag reference.

27 min readLast reviewed October 19, 2026Verified against nt 0.0.4 (published 2026-10-19)

What you’ll have at the end

By the end of this guide you will have nt installed, signed in to your Nautili team, and a coding session running in your terminal against your team's gateway. You will also know how nt runs behind the scenes, how to run it as a server that scripts, CI jobs and other machines can drive, and where every flag and environment variable is documented.

Before you begin

  • A Nautili account on a team. Sign up at nautili.ai if you do not have one, and ask a team admin to confirm the team has a gateway and at least one connected provider.
  • macOS (Apple silicon or Intel) or Linux (x64 or arm64) with curl, and tar (Linux) or unzip (macOS) on your PATH; or Windows (x64 or arm64) with PowerShell. Both are covered under Install.
  • A browser on the same machine for the first sign-in. Headless machines use a token instead, see Step 6.
  • A git repository to work in. nt scopes sessions to the directory you start it from.

Step 1: Install nt

curl -fsSL https://nautili.ai/install.sh | bash

The script detects your OS and CPU, downloads the matching archive from releases.nautili.ai, checks it against the release's SHA256SUMS, and places the binary at ~/.nautili/bin/nt.

It then adds ~/.nautili/bin to your PATH, but only if it is not already there. It picks the config file from $SHELL: for zsh, the first of .zshrc, .zshenv (under $ZDOTDIR or your home) or their $XDG_CONFIG_HOME/zsh copies; for bash, .bashrc, .bash_profile, .profile or their $XDG_CONFIG_HOME/bash copies; for fish, a fish_add_path line in ~/.config/fish/config.fish; for any other shell, .profile, .bashrc or .bash_profile. If none of those files exists, it prints the export PATH=... line for you to add yourself.

The installer accepts these flags after bash -s --:

FlagEffect
-v, --version <version>Install a specific version instead of the one in the stable manifest, for example --version 0.0.4. A leading v is stripped. VERSION=0.0.4 in the environment does the same when piping.
-b, --binary <path>Install from a local binary instead of downloading.
--no-modify-pathDo not edit any shell config file. You add ~/.nautili/bin to PATH yourself.
-h, --helpPrint the usage text.
curl -fsSL https://nautili.ai/install.sh | bash -s -- --version 0.0.4 --no-modify-path

Open a new shell, then confirm the binary is on your path. It prints the version:

nt --version
nt v0.0.4

Platform notes:

  • Alpine and other musl Linux. The musl build links libstdc++ dynamically and Alpine does not ship it. Run apk add libstdc++ before the first nt. The installer prints this reminder when it picks a -musl target.

  • Windows. There is a PowerShell installer. In Windows PowerShell 5.1 or PowerShell 7, run:

    irm https://releases.nautili.ai/install.ps1 | iex

    It reads the same release manifest, downloads nt-windows-x64.zip (or -arm64, or -x64-baseline on a CPU without AVX2), checks it against SHA256SUMS, puts nt.exe in ~\.nautili\bin, and adds that directory to your user PATH. Run the script from a file to pass flags: -Version <v>, -InstallDir <path>, -NoModifyPath. When piping, $env:VERSION = "0.0.4" pins the version.

  • GitHub Actions. When GITHUB_ACTIONS=true, both installers also append the install directory to $GITHUB_PATH, so later steps in the job find nt without a PATH edit.

To move to the current release later, run the upgrade command (nt update is an alias):

nt upgrade

nt upgrade acts only on a copy it recognises: the installer's binary in ~/.nautili/bin, or an @nautili/tui install made with npm, pnpm, bun or yarn. For the installer's copy it re-runs the installer with the target version; on Windows that is the PowerShell installer. For any other nt it refuses with Nautili at <path> is not managed by its installer. Pass --method curl to install the current version with the installer, or run: curl -fsSL https://nautili.ai/install.sh | bash. nt upgrade 0.0.4 pins a version, and an explicit target may also downgrade; without a target, nt upgrade never moves below the published release.

Step 2: Sign in

nt login

nt login starts a browser OAuth flow. It prints Authorize Nautili in your browser and choose a team. and the authorization URL, opens the URL in your browser when run from a terminal, and waits for you to approve and pick a team. On approval it prints Logged in as <email> (<team>).

The credential is stored in ~/.local/share/nautili/nautili.db ($XDG_DATA_HOME is respected), encrypted with a key held in the OS keychain: macOS Keychain, Secret Service on Linux, or DPAPI on Windows. On a headless host with no keychain, the key falls back to a credential.key file (mode 0600) beside the database, and nt prints a one-time notice saying so. DEVZERO_CREDENTIAL_STORE=keyring or =file forces one or the other.

The same login covers the TUI, nt run, nt serve and the desktop app on this machine, because they all share the background service described in How nt runs. nt login takes only --standalone or --server <url> to sign in a different server.

Check what the install thinks it is:

nt whoami
you@example.com (Acme)
Inference gateway for the team "Acme": <gateway-name> at https://<your-gateway-host>
Backend: https://api.nautili.ai
Access token expires: 2026-10-19T18:12:04.000Z (in 3598s)

The gateway line matters. When the gateway is ready it names the gateway and the URL the client will send traffic to; any other state is spelled out instead, with a remedy line under it saying what to do, and the TUI shows the gateway state in its status line. The access token refreshes on its own before it expires.

nt whoami --json prints the same state as data, with no token in it, and it succeeds even when nothing is logged in. The fields are trimmed here to the ones you will look at:

{
"authenticated": true,
"source": "login",
"personalAccessToken": false,
"server": "https://api.nautili.ai",
"email": "you@example.com",
"teamName": "Acme",
"expires": "2026-10-19T18:12:04.000Z",
"expired": false,
"gateway": { "state": "ready", "url": "https://<your-gateway-host>" }
}

nt logout revokes the grant on the DevZero side and removes the local row, printing Logged out of DevZero. If the revoke call fails, it still signs out locally and tells you to withdraw the session from the dashboard. If DEVZERO_TOKEN is set where the server runs, it adds Still signed in with DEVZERO_TOKEN: unset it where the server runs to sign out.

Step 3: Set your defaults

nt reads a config file named nautili.jsonc, nautili.json, opencode.jsonc or opencode.json. The global copy lives in ~/.config/nautili/. A project can carry its own at the repo root, or inside a .nautili/ directory (.opencode/ is read too), and it merges on top of the global file. The keys most people set:

{
// Model to open new sessions with, as provider/author/slug.
// `nt models` lists the exact ids your team's gateway serves.
"model": "devzero/anthropic/claude-haiku-4.5",
// Legacy key, still honoured: the model for background work such as session titles.
"small_model": "devzero/anthropic/claude-haiku-4.5",
// Primary agent to start in: build (default) or plan.
"default_agent": "build",
// true installs releases automatically, false disables the check,
// "notify" (the default) only tells you. The native spelling is
// "update": "auto" | "disable" | "notify".
"autoupdate": "notify"
}

Each key is optional. nt models prints the ids your gateway serves, in the form devzero/<author>/<slug>; the part after devzero/ is the same model id the gateway accepts over HTTP.

Server settings are not config keys. The background service's address is set with nt service set port 4096 and nt service set hostname 0.0.0.0, see How nt runs.

TUI keybindings live under a keybinds object in the same config file. Names are dotted; the defaults are listed in Step 4 and you only add the entries you change. A tui.json from an older version is migrated into the config file on first run.

{
"keybinds": {
"leader": "ctrl+x",
"session.new": "<leader>n"
}
}

Step 4: Work in the TUI

Start nt from inside a repository:

cd <project>
nt

The TUI opens on a new session scoped to that directory, with the model from your config selected. Type a prompt and press return to send it; shift+return inserts a newline. While the agent is working, escape interrupts it. A permission prompt appears before nt edits a file or runs a command it has not been allowed to; answer it in place.

Starting options worth knowing:

CommandWhat it does
nt ~/src/other-repoStart in a different directory without cd.
nt -cContinue the most recent session in this directory.
nt -s <session-id>Reopen a session, or create one with that id.
nt --prompt "explain the build"Start with a prompt already submitted.
nt --autoAuto-approve every permission that is not explicitly denied. Use with care.
nt --standaloneRun against a private server for this one process instead of the background service.
nt --server http://host:portAttach to a server you started elsewhere; set NT_PASSWORD for its password.
nt miniThe minimal interface. Takes -c, -s, --fork, -m <provider/model>, --agent, --prompt, and --no-replay or --replay-limit <n> to control history replay.

The key bindings below are the defaults. The leader key is ctrl+x: press it, release, then press the second key.

KeysAction
ctrl+pCommand palette. Everything below is reachable from here by name.
ctrl+x nNew session
ctrl+x lList sessions
ctrl+oOpen recent sessions and projects
ctrl+x mList models and switch the current session to one
f2 / shift+f2Cycle recently used models forward or back
ctrl+tCycle the model variant (provider-specific reasoning effort)
ctrl+x a, shift+tabList agents, or cycle to the next agent
ctrl+x cCompact the session to reclaim context
ctrl+x eOpen the external editor for the prompt
ctrl+x y / u / rCopy, undo or redo the last message
ctrl+x bToggle the sidebar
ctrl+x tToggle the terminal pane
ctrl+x sStatus view, including the gateway state
ctrl+rRename the session
escapeInterrupt the running turn
ctrl+c, ctrl+d, ctrl+x qExit

Switching models mid-session is the common case for cost control: open ctrl+x m, pick a cheaper model for the next turn, and the session keeps its history. The dashboard records which model served each request, so a session that moved between models shows both.

For one-shot work without the interface, nt run sends a message and prints the reply:

nt run "summarize the failing tests in this repo"

nt run reads a message from its arguments, from stdin when piped, or both. It uses the same session store as the TUI, so nt run -c "now fix the first one" continues the last session, and nt -c later opens it in the TUI. --format json emits raw events for scripting, -f <path> attaches files, and --title names the session.

git diff | nt run --format json "review this diff for bugs" > review.jsonl

How nt runs

Every nt command talks to a background service: one server process per machine, listening on port 49380 (45284 on Windows), started on demand the first time a command needs it and kept running afterwards. The TUI, nt run, nt models and the desktop app all connect to it, which is why a login in one covers them all. nt service start|status|stop|restart manages it, and nt service set hostname|port|password|cors <value> changes its settings, stored in ~/.config/nautili/service.json; the running service's address is registered under ~/.local/state/nautili/service.json. Any setting change stops the service so the next command restarts it with the new value.

Two flags step around the service. --standalone starts a private server for that one command and stops it afterwards. --server <url> targets any server, local or remote, with the password from NT_PASSWORD.

Step 5: Run a server for scripts and other machines

nt serve runs the same server in the foreground, on an address you choose:

nt serve --port 4096
server listening on http://127.0.0.1:4096
server password <random>
open in a browser http://127.0.0.1:4096/?auth_token=...

Without a password in the environment the server generates one and prints it, with a link that signs a browser in. Pass --port so the address is predictable. The hostname defaults to 127.0.0.1; pass --hostname 0.0.0.0 to accept connections from other machines, and set the password yourself when you do:

NT_PASSWORD='<a long random string>' nt serve --port 4096 --hostname 0.0.0.0

The server uses HTTP basic auth with the fixed username opencode and that password. NT_PASSWORD is the variable to set; the older NT_SERVER_PASSWORD is still honoured. There is no unsecured mode. --cors <origin> (repeatable) adds allowed browser origins.

Check it is up. /api/info needs no login and returns the server's info JSON:

curl -u opencode:"$NT_PASSWORD" http://127.0.0.1:4096/api/info

The login gate applies to the server too. Until it has a credential from nt login (or a DEVZERO_TOKEN in its environment), only /api/info, /openapi.json, the DevZero integration and OAuth routes, the OAuth callback, and the status and logout RPCs answer; everything else returns 401 with Log in to DevZero to use Nautili. Sign in before you start the server, or supply a token as in Step 6.

Drive it from a script. The server publishes its API as /openapi.json, and nt api calls any operation in it by operationId, or by METHOD /path:

nt api --help
nt api <operationId | METHOD /path> [-d '<json body>'] [-H name:value] [--param key=value]
# against a server you started yourself:
NT_PASSWORD="$NT_PASSWORD" nt api --server http://127.0.0.1:4096 GET /api/info

Every request that touches a project names it with the x-opencode-directory header (an absolute path on the server); without it the server uses its own working directory. --param fills path parameters and adds the rest as query parameters; -d sends a JSON body. On a non-2xx response nt api prints HTTP <status> to stderr and exits 1.

To work interactively against a server on another machine, point a client at it:

NT_PASSWORD='<the password>' nt --server http://<host>:4096

-c and -s <id> work the same as for a local nt, and nt run --server http://<host>:4096 "..." does the one-shot equivalent. The desktop app can add the same server under Settings, Servers.

Step 6: Run nt in CI

A runner has no browser, so it signs in with a token. When DEVZERO_TOKEN is set, nt starts a private server for the command (the same thing --standalone does; pass it anyway so the intent is visible), and that server exchanges the token for a short-lived access token when it starts. nt whoami --json then reports the real gateway.state, and nt models lists the catalogue. If the account belongs to several teams, also set DEVZERO_TEAM=<team id> so the exchange knows which one to act for. Store the token as a repository secret, never in the workflow file.

name: nightly-review
on:
schedule:
- cron: "0 3 * * 1-5"
jobs:
review:
runs-on: ubuntu-latest
env:
DEVZERO_TOKEN: ${{ secrets.DEVZERO_TOKEN }}
steps:
- uses: actions/checkout@v4
- name: Install nt
run: curl -fsSL https://nautili.ai/install.sh | bash
- name: Confirm identity
run: nt whoami --standalone --json
- name: Review yesterday's commits
run: |
git log --since=yesterday -p | \
nt run --standalone --format json --title "nightly review ${{ github.run_id }}" \
"Review these commits for bugs and list them with file and line." > review.jsonl
- uses: actions/upload-artifact@v4
with:
name: review
path: review.jsonl

The installer appends ~/.nautili/bin to $GITHUB_PATH, so the later steps find nt. nt run refuses with Not logged in to DevZero. Run `nt login`. and exit code 1 when stdout is not a TTY and no identity is present, which is the failure you want on a misconfigured secret. nt models exits non-zero with the backend's reason when the token was refused, so an empty catalogue never reads as success.

With a token, nt whoami prints <email> (<team>) and then Signed in with DEVZERO_TOKEN (personal access token exchange). If the machine also has a stored login, the stored login wins and nt whoami says so: DEVZERO_TOKEN is set but unused: the stored login wins. Run `nt logout` to use it. The long-lived background service never inherits a token from the shell that started it; nt service set env DEVZERO_TOKEN <value> is the way to give it one.

Verify

Everything nt sends goes through the same gateway as your SDK traffic, so the dashboard is where you confirm it worked.

  1. Send one prompt from the TUI or nt run.
  2. Open Spend. Group by user and the row for your account moves. Group by workload type and the request sits under nautili: the client stamps X-Dz-Workload-Type: nautili on every request, and a User-Agent of nautili/prod/0.0.4/cli. Each request also carries X-Dz-Session-Id, X-Dz-Labels: agent=<agent> and a W3C traceparent derived from the root session, so a resumed session rejoins its trace. The gateway strips any X-Dz-User or X-Dz-Team a client sends, because the token already carries both, verified.
  3. Open Traces and find the request. The decision record shows the requested, decided and served model. In shadow mode a guardrail's would-deny is recorded on the trace while the request is still served; in enforce mode the deny surfaces in the TUI as a provider error.

Locally, nt whoami is the health check. DEVZERO_TRACE=1 nt whoami --standalone --print-logs logs each call the server makes to the control plane (method, path, status, duration, whether a bearer was attached, and no token or body); the trace has to run on a server you start, which is what --standalone does.

Options

Only flags present in the current build are listed. Hidden development-only flags are omitted.

nt

nt [directory] [flags]

Starts the TUI. directory is a path to start in; relative paths resolve from your shell's working directory.

FlagTypeDefaultDescription
-c, --continueTypebooleanDefaultDescriptionContinue the last session in this directory
-s, --session <id>TypestringDefaultDescriptionSession id to continue, or to create if it does not exist
--prompt <text>TypestringDefaultDescriptionPrompt to submit on start
--autoTypebooleanDefaultfalseDescriptionAuto-approve permissions that are not explicitly denied
--standaloneTypebooleanDefaultfalseDescriptionRun with a private server instead of the background service
--server <url>TypestringDefaultDescriptionConnect to a server URL instead of the background service

Other commands: upgrade (alias update), uninstall (--dry-run, -f/--force), acp, api, debug agents|config|paths, auth list|login|logout|export|import|switch, login, logout, whoami, mcp list|add|auth|logout, plugin list|add|check|update|remove, models, stats, mini, run, session list|delete|export|import, service start|restart|status|stop|get|set|unset, reload, pair, serve. nt <command> --help lists each one's flags.

nt mini

nt mini [flags]

The minimal interactive interface. Takes -c, -s <id>, --fork, -m <provider/model>, --agent <name>, --prompt <text>, --replay / --no-replay and --replay-limit <n> (default 200), plus --standalone and --server <url>.

nt run

nt run [message..] [flags]

Sends one message and prints the reply. Message text comes from the arguments, from piped stdin, or both. Needs an identity: it prompts for login on a TTY and exits 1 otherwise.

FlagTypeDefaultDescription
-c, --continueTypebooleanDefaultDescriptionContinue the last session
-s, --session <id>TypestringDefaultDescriptionSession id to continue, or to create if it does not exist
--forkTypebooleanDefaultDescriptionFork before continuing (requires -c or -s)
-m, --model <provider/model#variant>TypestringDefaultconfig modelDescriptionModel to use, for example -m devzero/anthropic/claude-haiku-4.5#high
--agent <name>TypestringDefaultDescriptionAgent to use
--format <default|json>TypestringDefaultdefaultDescriptionFormatted output, or raw JSON events
-f, --file <path>Typestring[]DefaultDescriptionFile(s) to attach to the message; repeatable
--title <text>TypestringDefaultDescriptionSession title
--thinkingTypebooleanDefaultfalseDescriptionShow thinking blocks
--autoTypebooleanDefaultfalseDescriptionAuto-approve permissions that are not explicitly denied
--standaloneTypebooleanDefaultfalseDescriptionRun with a private server instead of the background service
--server <url>TypestringDefaultDescriptionSend to a server URL instead of the background service

nt serve

nt serve [flags]

Starts the server in the foreground.

FlagTypeDefaultDescription
--port <n>TypenumberDefaultDescriptionPort to listen on
--hostname <host>TypestringDefault127.0.0.1DescriptionInterface to bind
--cors <origin>Typestring[]DefaultDescriptionAdditional allowed CORS origin; repeat for several
--serviceTypebooleanDefaultfalseDescriptionRun as the background service (what nt service start launches)
--stdioTypebooleanDefaultfalseDescriptionReport the address as JSON on stdout and exit when stdin closes (what --standalone launches)

nt service

nt service start|restart|status|stop
nt service get [key]
nt service set <key> <value>
nt service unset <key>

Manages the background service. Keys: hostname, port, password, cors (comma-separated origins), disabled (true stops the service and makes every command run standalone), and env (nt service set env <NAME> <value>, for variables the service should run with).

nt api

nt api <operationId | METHOD /path> [flags]

Makes one request to the server and prints the response body.

Flag-d, --data <body>TypestringDescriptionRequest body; content-type: application/json is set unless you pass one
Flag-H, --header <name:value>Typestring[]DescriptionRequest header; repeatable
Flag--param <key=value>TypestringDescriptionOpenAPI path or query parameter
Flag--standalone, --server <url>TypeDescriptionAs for nt

nt models

nt models [--standalone] [--server <url>]

Lists the models your team's gateway serves, one providerID/id per line, sorted, for example devzero/anthropic/claude-haiku-4.5. Needs an identity. Exits non-zero with the backend's reason when a DEVZERO_TOKEN is refused.

nt login

nt login [--standalone] [--server <url>]

Opens the browser OAuth flow and stores the credential on the server it talks to.

nt logout

nt logout [--standalone] [--server <url>]

Revokes the grant server-side, then removes the local credential, the cached gateway choice and the team instructions.

nt whoami

nt whoami [--json] [--standalone] [--server <url>]

Prints the signed-in account, team, gateway state, backend and token expiry.

FlagTypeDefaultDescription
--jsonTypebooleanDefaultfalseDescriptionDump the runtime state as JSON (never includes a token); succeeds when logged out

nt upgrade

nt upgrade [target] [flags]

Installs the current release, or target (0.0.4 or v0.0.4). Skips when the target is already installed. Without a target it never moves below the published release; an explicit target can.

Flag-m, --method <name>TypestringDescriptionInstallation method: curl (the installer; the PowerShell installer on Windows), npm, pnpm, bun, yarn, vp, brew, winget. Detected when omitted; only curl and the npm-family methods apply to Nautili.

Global flags

These apply before any command.

FlagDescription
-h, --helpShow help for nt or a subcommand
--versionPrint the version
--print-logsPrint logs to stderr; server logs require --standalone
--trace [filter]Log every outbound HTTP call and every request served; --trace=<filter> narrows it to origins and paths containing one of the comma-separated filters, for example --trace=api.nautili

Environment variables

VariableEffect
DEVZERO_TOKENPersonal access token. The server exchanges it for a short-lived access token at start, for headless and scripted use. A command run with it set uses a private server.
DEVZERO_TEAMTeam id a DEVZERO_TOKEN acts for, needed when the token's account is in more than one team.
DEVZERO_CREDENTIAL_STOREkeyring or file: force where the credential key is kept. Default: the OS keychain, falling back to a file.
DEVZERO_TRACE1 logs every call to the Nautili control plane, one line each: method, path, status, duration, whether a bearer was attached. No token or body is ever logged. 0, false or off disable it.
NT_TRACEWhat --trace sets. 1 traces all hosts; any other value is a comma-separated filter.
NT_PASSWORDBasic auth password: adopted by nt serve, and sent by clients using --server. NT_SERVER_PASSWORD is the legacy name and still works.
NT_CONFIGPath to a config file to load instead of the discovered ones.
NT_CONFIG_DIROverride the config directory.
NT_DISABLE_AUTOUPDATE1 stops the client from checking for and installing releases on its own.
NT_PRINT_LOGS, NT_LOG_LEVELNT_PRINT_LOGS=1 is what --print-logs sets; NT_LOG_LEVEL sets the level of those logs.
NAUTILI_RELEASES_URLInstaller only: base URL for the release manifest and archives, default https://releases.nautili.ai.
NAUTILI_BINARYInstaller only: the binary name to install, default nt.
NAUTILI_INSTALL_DIRInstaller only: where to put the binary, default ~/.nautili/bin.

Every NT_* variable is copied to its OPENCODE_* name at startup, so either spelling works.

Troubleshooting

Symptom or errorCause and fix
nt: command not found after installThe shell config was edited but not reloaded, or --no-modify-path was used. Run export PATH=$HOME/.nautili/bin:$PATH or open a new shell.
Unsupported OS: MINGW64_NT... from the installerThe bash installer does not run on Windows. Use the PowerShell installer: irm https://releases.nautili.ai/install.ps1 | iex.
Checksum mismatch for nt-linux-x64.tar.gz ... Nothing was installed.The download did not match SHA256SUMS. Retry; if it persists, a proxy is altering the download.
Error loading shared library libstdc++.so.6 on AlpineThe musl build needs libstdc++. Run apk add libstdc++.
Not logged in to DevZero. Run `nt login`.A gated command (the TUI with -s, run, mini, models, stats, acp, reload, session *, mcp *, plugin *, debug agents, debug config) ran without an identity on a non-TTY. Sign in, or set DEVZERO_TOKEN.
Log in to DevZero to use Nautili (HTTP 401) from a serverThe server has no credential. Run nt login against it (--server <url> for a remote one), or start it with DEVZERO_TOKEN set.
DEVZERO_TOKEN is set but unused: the stored login wins.Both identities are present. nt logout removes the stored login if the token is the one you want.
The gateway line in nt whoami is not readynt whoami prints the state and the remedy; the TUI shows the same in its status line. Usually the team has no gateway resolved yet; ask a team admin.
Server at <url> requires a password; set NT_PASSWORD--server was used without a password. Export NT_PASSWORD with the server's password.
Server at <url> rejected the passwordWrong NT_PASSWORD for that server.
Could not reach server at <url>Nothing is listening there, or a firewall is in the way. Check nt serve is running on that host and port.
Warning: Server at <url> has version X; this client is Y. Continuing anyway.Client and server differ. Upgrade both to the same release.
401 from curl against nt serveBasic auth is on. Use -u opencode:<password>.
Managed service port 49380 on 127.0.0.1 is already in use by another process.Something else holds the service port. nt service set port <port>, then run the command again.
--fork requires --continue or --session--fork only applies when resuming. Add -c or -s <id>.
You must provide a messagent run got empty input. Pass a message argument or pipe stdin.
Nautili at <path> is not managed by its installer.nt is not at ~/.nautili/bin/nt and not an npm-family install. Run the install command it prints, or nt upgrade --method curl.

Next steps

Ready to keep going?

Explore the next guide or start routing through Nautili.