# How to Use the Moshcode CLI

> Source: <https://anthony.dev.profullstack.com/blog/002-post.html>
> Published: 2026-08-14 12:34:59+00:00

# How to use the moshcode CLI

*2026-08-14, by Anthony “chovy” Ettinger.*

**How this was written:** drafted with an AI assistant from my notes and from the
CLI's own help output, then checked against a real install. Commands below were run against
moshcode 0.56.0.

## What moshcode actually is

moshcode calls itself “a metal wrapper for coding engines.” That is the honest
description. It is not another coding agent competing with the ones you already use — it
*installs and drives* them. opencode, Claude Code, codex, gemini, kimi, qwen, deepseek,
aider and a few more all sit behind one command surface, so you stop memorising five different
CLIs with five different flag conventions.

On top of that it adds the things you actually need around an agent: sessions that survive a
closed terminal, an account you can sync settings to, and a namespace where you can park what you
build. Home page is [moshcode.sh](https://moshcode.sh).

## Installing it

```
curl -fsSL https://moshcoding.com/install.sh | sh
```

Yes, the site is `moshcode.sh`

and the installer is served from
`moshcoding.com`

. They are two different properties and that trips people up. The
install script is the one above.

It is zero-dependency ESM, so the only requirement is Node.js 18 or newer. The same script handles the other two lifecycle jobs:

```
curl -fsSL https://moshcoding.com/install.sh | sh -s -- update
curl -fsSL https://moshcoding.com/install.sh | sh -s -- remove
```

**Do not put sudo in front of that.** moshcode escalates on its own
for the steps that genuinely need root. If you run the installer or an update as root, it installs
into root's home directory instead of yours, and then you have two copies and a confusing
afternoon. Run it as you.

## Finding your way around

Run it with no command at all and it opens the mosh pit — the interactive view. When you want the map instead:

```
moshcode help                # the groups
moshcode help <command>      # flags and examples for one
moshcode help --all          # the whole wall
moshcode help --json         # the same thing, for a script
```

The commands are grouped, which is the fastest way to understand the tool: **engines**
(agents, install, upgrade), **runtime** (herd, ps, attach, kill, restore),
**tools** (stocks, crypto, news, rss, trade), **extend** (mcp, skill,
plugin), **script** (prd, commands, run), **account** (login, whoami,
save, load), and **hosting** (dns, doh, site, template). There is also an arcade with
twenty-two games in it, because of course there is.

That `--json`

flag is not decoration. Nearly every command takes it, which is what
makes moshcode scriptable rather than merely interactive.

## Driving an engine

```
moshcode engines             # what exists, and what's installed here
moshcode install claude      # put one on this machine
moshcode agents              # engines and their status
moshcode agents claude       # open that engine's agent view
```

One warning, straight from the CLI's own help text: *autonomous modes bypass approval
prompts.* Use them in a container or a workspace you trust, and not in the checkout you care
about. That is not me being cautious for the sake of it — an agent that never asks is exactly
as dangerous as it sounds.

## The herd: sessions that outlive the terminal

This is the feature I use most and the one that is hardest to appreciate until you have it. A herd session keeps running when you close the window.

```
moshcode herd start          # start a session, hand the prompt back
moshcode herd ps             # the roster and every session's state
moshcode attach              # get back into one
moshcode herd tile           # every member on screen at once
moshcode herd ui             # sidebar of members, selected one beside it
moshcode kill                # stop one
moshcode restore             # bring sessions back
```

Once you are running three or four agents at once, `herd tile`

and the roster stop
being conveniences and start being the only way you keep track of anything.

## Logging in

An account lives at [app.moshcode.sh](https://app.moshcode.sh) and the CLI
authenticates against it:

```
moshcode login               # browser flow
moshcode login --device      # device-code flow, for a headless box
moshcode whoami              # who am I currently
moshcode whoami --json       # same, for a script
moshcode logout
```

The device flow is the one you want over SSH; moshcode picks it automatically when stdin is not a TTY, but you can force it. Once you are signed in, your settings become portable:

```
moshcode save --dry-run      # what would go up
moshcode save                # push aliases + herd rules to your account
moshcode load                # pull them onto another machine
```

That is the whole reason to bother logging in: set a box up once, then `moshcode load`

on the next one instead of doing it all again.

## Joining the Pit network

The Pit, at [app.moshcode.sh/pit](https://app.moshcode.sh/pit), is the part people
find strangest, so here is the plain version. It is a namespace that lives *outside* the
traditional DNS root. You claim an *ending* — the moral equivalent of a TLD, something
like `.eggs`

— on a first-come, first-served basis, and then you mint as many names
under it as you like. Sign in with the same moshcode account the CLI uses, and claim one.

Because these names are not in the public DNS root, a normal machine has no idea what to do with
them. That is what the `dns`

command is for:

```
sudo moshcode dns enable     # route Moshpit endings to the local bridge
moshcode dns status          # what's running, what's routed, does it work
moshcode dns resolve blue.eggs   # what a machine actually gets, and why
moshcode dns tlds            # every ending claimed in the Pit
moshcode dns refresh         # re-apply routing for endings claimed since
```

`dns enable`

is the one command here that genuinely does want `sudo`

, and
the CLI says so itself — it is rewriting your machine's resolver configuration. This is worth
typing deliberately rather than pasting on autopilot: it changes how *everything* on that box
resolves names, so do it on a machine where you would be comfortable explaining what changed. It is
reversible with `dns disable`

.

Then put something behind the name:

```
moshcode template list                     # available stacks
moshcode template install bun-caddy-sqlite # scaffold into the current dir
moshcode site                              # web-server config for a Moshpit name
```

If you would rather not touch your resolver at all, there is a DNS-over-HTTPS endpoint you can
point a client at instead — `moshcode help doh`

covers it.

## The bits nobody mentions

Some of the most useful surface is filed under “tools” and easy to miss:

`moshcode stocks`

and`moshcode crypto`

— market research from advis0r.com, straight in the terminal,`--json`

included`moshcode news`

and`moshcode rss`

— feeds without a reader`moshcode mcp`

,`skill`

,`plugin`

— how you extend an engine rather than replace it`moshcode secrets`

,`railway`

,`gh`

,`supabase`

,`turso`

— the adjacent tools it will install and drive for you`moshcode upgrade --check`

— what is stale, without installing anything

## A sensible first hour

- Install it with the curl line. No sudo.
`moshcode help`

, then`moshcode help herd`

.`moshcode install`

whichever engine you already pay for.`moshcode login`

—`--device`

if you are on a server.- Start one thing under
`herd start`

and close the terminal on purpose. Reattach. That moment is when it clicks. - Only then go claim an ending in
[the Pit](https://app.moshcode.sh/pit).

Leave `dns enable`

until you actually want to reach a Moshpit name from that machine.
It is the one step with system-wide consequences, and there is no reason to take it on day one.

Written against moshcode 0.56.0; commands and flags move, so
`moshcode help <command>`

is always more current than a blog post. Disclosure: I
build moshcode, so I am hardly a neutral reviewer of it.
