# DeepCell, for the agent reading this

Everything needed to go from nothing to a working .deepcell document: which path fits the environment you are running in, how to set it up, and what to do when a command fails. No account required to start.

Source: https://deepcell.net/product/for-agent.md

## Work out where you are

DeepCell reaches the same service two ways. Which one is right depends on a single property of the environment you are running in — whether you can execute shell commands. Decide from the table, then read only that section.

| What you can do | Take | How to tell |
| --- | --- | --- |
| Run shell commands | The plugin, then the CLI it drives | You have a terminal, Bash, or an exec tool. Claude Code, Cowork, OpenWork, CI jobs, and anything with a sandbox are all here. If your client installs plugins, start there — the skill carries the working guidance; the CLI alone carries only the commands. |
| Reach MCP servers, but no shell | The MCP server | Your host has a connectors or MCP-servers setting — though only the person using it can change it. claude.ai, ChatGPT, and Manus are all here. |
| Neither — only fetch URLs | Read-only | You can read this page and any share link someone sends you, but you cannot build. Ask the person you are working with for a shell, or to add the MCP server. |

One line: a host that installs plugins starts with the plugin — it carries the skills, and its skill sets up the CLI. Otherwise shell means the CLI, no shell means MCP. If you have both a shell and MCP, take the CLI — it is the larger surface, because sign-in, upgrades, Office/PDF exports, and the whole clone / pull / push / commit / merge history need capabilities the MCP server does not have.

## Start with the plugin

If your host can install plugins, do this first. The plugin is the skills — the working instructions that tell your agent what a .deepcell document is, what done means, and how to drive the CLI — packaged so the host loads them automatically. Its skill checks for the deepcell command and runs the installer itself when the command is missing, so this one step sets up everything. In Claude Code:

Claude Code
```bash
/plugin marketplace add deepcell-ai/deepcell-plugins
/plugin install deepcell@deepcell
/reload-plugins
```

Every other plugin-capable client uses the same directory through its portable manifest — DeepCell is published as a plugin conforming to Agent Plugins Specification v1.0.0, and the repository root is the plugin:

```bash
https://github.com/deepcell-ai/deepcell-plugins
```

The specification defines no install command, so point your client at that repository the way it takes a plugin directory.

No plugin support? Nothing is lost. The sections below set up the same access by hand, and the skill's entire content is readable once the CLI or MCP connection is up: deepcell guide orient/how-to-work.

## The CLI path

One command. It works on Windows, macOS and Linux, and on a machine with no pip, no venv module, or a Python that refuses to install into itself — the script sorts that out rather than asking you to.

macOS / Linux
```bash
curl -LsSf https://deepcell.net/install.sh | sh
```

Windows (PowerShell)
```powershell
irm https://deepcell.net/install.ps1 | iex
```

It installs with uv or pip, whichever the machine has, fetching uv first if it has neither; finds where the deepcell command actually landed; adds that directory to your shell profiles so it is still there in the next shell; and runs deepcell --version before reporting success. Running it twice is safe. In the shell you are already in, use the export line it prints — or just start a new one.

Would rather not pipe a download into a shell? Fetch it, read it, then run it. Same script:

macOS / Linux
```bash
curl -LsSf https://deepcell.net/install.sh -o install-deepcell.sh
less install-deepcell.sh
sh install-deepcell.sh
```

Windows (PowerShell)
```powershell
irm https://deepcell.net/install.ps1 -OutFile install-deepcell.ps1
Get-Content install-deepcell.ps1
powershell -ExecutionPolicy Bypass -File install-deepcell.ps1
```

Now check the environment in one command. It reports the version, whether the server is reachable, who you are, which project is active, and what to run next:

```bash
deepcell doctor
```

Parse the answer instead of reading it — the JSON carries a next_command field for exactly this:

```bash
deepcell doctor --format json
```

## The MCP path

One remote server, one tool. Once it is added to your host, every CLI command becomes a call to that tool with the command as a string.

You cannot add it yourself. It is a setting in your host, not something a tool call can reach — so this is the one step on this page you hand to the person you are working with. Give them the URL and the steps below, then ask them to say when it is connected.

On claude.ai, this is added as a remote MCP server — sign-in happens in their browser, so there is no key for anyone to paste:
```bash
https://deepcell.net/mcp
```

- Open claude.ai → Settings → Integrations.
- Choose Add MCP Server.
- Paste the URL above and confirm.
- A browser sign-in opens and completes on its own — nothing gets copied back to you.

On Manus and other MCP clients, use a config file with an API key. Keys are created under Settings, API keys on the website, and start with dck_:

```bash
{
  "mcpServers": {
    "deepcell": {
      "type": "streamableHttp",
      "url": "https://deepcell.net/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}
```

Then call the one tool with a command string, exactly as you would type it after deepcell:

```bash
guide orient/start
```

Some commands are refused here because they need a browser, a binary, or a working copy: account, clone, login, logout, merge, pull, push, register, status, to-docx, to-excel, to-pdf, to-pptx, upgrade, variant, verify-email. A refusal is reported before anything runs, so nothing changed.

## Start

You do not need an account. The first command that needs the server mints an anonymous session and a scratch project on its own, so go straight to work:

```bash
deepcell guide orient/start
deepcell ls
```

If the DeepCell plugin is already loaded, skip this duplicate. Otherwise read the same working contract here before building anything substantial — it is the instruction set used by the plugin and hosted agent, and says what the work is and when it is done:

```bash
deepcell guide orient/how-to-work
```

Use five reference surfaces instead of guessing: command --help or deepcell help [command] for exact invocation and exits; deepcell rules [id] for invariants; deepcell guide [topic] for the procedure that applies now; deepcell ref [id] for legal names and values; deepcell example for complete valid artifacts and transcripts.

Then take a goal and its constraints, not a procedure:

> Compare the vendor proposals in ./proposals and recommend whether we should build or buy. Record the assumptions, evidence, rejected alternative, and what new evidence would change the decision; deliver a concise decision memo.

Inspect the project and any existing file before writing. Trust the installed help, rules, guides, refs, and examples over anything you remember. Never edit a .deepcell file with a text editor: that skips the calc engine, validation, and version history, which is how a document ends up disagreeing with itself.

A .deepcell document connects four selectable surfaces — Reasoning, Spreadsheet, Document and Deck. Use only what the question needs: qualitative work can be complete with Reasoning and Document and no grid; another task may need all four. Recalculation updates calculation dependents, while linked claims, prose and slides must be reassessed explicitly rather than silently rewritten. If your host also offers direct .xlsx, .docx or .pptx authoring tools, do not use them here because those files lose the connected source of truth.

That costs the reader nothing, because nobody has to hold the file to see the work. deepcell share create returns a link that opens it on the DeepCell website with the connections intact, and deepcell to-excel, to-docx, to-pptx and to-pdf produce editable files from the document — to-excel --formulas carries live formulas rather than flattened values. So when someone asks for a spreadsheet or a deck, build it in DeepCell and hand them the export.

## Anonymous, account, verified

Three states, and you start in the first one without doing anything. Escalate when a command tells you to — not before.

| State | How you get there | What it gives you |
| --- | --- | --- |
| Anonymous | Nothing. The first command that needs the server mints one and tells you it did. | Create projects, write, edit, query, read every guide, and share a view-only link for up to 7 days. It is a temporary demo project: it is collected after 30 days of inactivity, and capped at 60 requests a minute and 2 MiB per document. Your agent runs are your own — the hosted chat's run allowance is a browser limit and never applies here. |
| Account | deepcell login — or deepcell register for a new one. | Permanent storage, share links with edit access and passwords, the Excel and PowerPoint exports, the sync commands, and the workbench in a browser. |
| Verified email | deepcell verify-email. | Creating projects on a new account, and anything else gated on a confirmed address. Note the asymmetry: an anonymous session can create a project, but a signed-in account with an unverified address cannot. |

```bash
deepcell login
```

Signing in opens a browser and finishes there. If you are an agent without one, print the URL and let the person you are working with complete it — it is their step, not yours.

Nothing is lost by starting anonymous. Signing in claims the anonymous work and moves it into the account, and if that fails it retries on the next sign-in.

## When a command fails

Match on the text — these are the literal strings the CLI and the MCP server emit. The two exit-code rows matter most: a non-zero exit does not always mean nothing happened.

| What you see | What it means | What to do |
| --- | --- | --- |
| Not authenticated. Run `deepcell login` first. | The anonymous session could not be minted — the server is unreachable, has anonymous access switched off, or DEEPCELL_NO_ANON is set. | Check the server is reachable with deepcell doctor, then sign in. |
| This needs an account. Run `deepcell login` | You are anonymous and asked for something only a full account can do. | Sign in. The anonymous work moves across automatically, so nothing is lost. |
| Email verification required. | The account exists but its address was never confirmed. | Run deepcell verify-email, then retry. |
| No active project. / No projects found. | No project is selected, or the account has none. | Run deepcell project use '<'slug>, or deepcell project create "My Project". deepcell doctor prints which one is active. |
| Could not connect to ... | Wrong base URL, or the service is down. | Check DEEPCELL_API_URL. Do not retry in a loop — nothing will change until the address does. |
| exit code 1 from write, push, commit, replace, or a reasoning writer | Saved AND invalid. These save first and validate after, so the file did change and the change does not hold up. | Read the reported problems, fix them, and write again. Never retry the same content blindly — you would save it twice. |
| exit code 1 from defs | The opposite: structure edits are whole-batch atomic, so nothing changed at all. | Fix the operation and send the batch again. |
| exit code 2 | The command itself was wrong — a bad flag, or a local file that is not there. | Run deepcell '<'command> --help for the exact flags. Do not guess a flag name. |
| Command '...' is blocked in MCP mode | Refused before it ran, so nothing changed. It needs a browser, a binary, or a working copy. | Use the CLI for that one, or ask the person you are working with to run it. |
| Demo rate limit exceeded. Try again in Ns. | The anonymous cap — 60 requests a minute. | Wait the reported number of seconds. Batch edits instead of sending them one at a time, or sign in. |

deepcell guide exit-codes has the full contract, including the two cases above and the three others that also exit 1.

The full command reference — every command, flag, exit code and guide topic — is at /product/cli, or /product/cli.md if you would rather read markdown.