> For the complete documentation index, see [llms.txt](https://docs.eesel.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.eesel.ai/apis-and-developer-resources/cli.md).

# The eesel CLI

The eesel CLI puts your teammate in your terminal. Chat with it, set up a website chat bubble, connect your helpdesk, upload knowledge, wire up automations, and approve held actions, all without opening the dashboard.

It's the same agent either way. Anything you set up in the CLI shows up in the dashboard, and the other way round. Every command prints JSON, so an AI coding agent (Claude Code, Cursor, Codex) can run your whole setup for you.

## Installing

Nothing to install. With Node.js 18.17 or newer:

```bash
npx @eesel/cli init chat-bubble --site https://your-site.com
```

That works with no account: it creates a free anonymous workspace ($5 of usage, 7 days) and `eesel login` later keeps it. If you'd rather type `eesel` than `npx @eesel/cli`, either of these puts an `eesel` command on your PATH:

```bash
npm install -g @eesel/cli
```

```bash
curl -fsSL https://dashboard.eesel.ai/eesel-cli/install | sh
```

The rest of this page writes `eesel ...`; `npx @eesel/cli ...` is the same thing.

## Logging in

```bash
eesel login      # opens your browser once; credentials are stored locally
eesel whoami     # who you're signed in as, and which workspace
eesel logout     # forget the stored credentials
```

You don't have to log in first. `eesel init` with no stored login creates an anonymous workspace and stores its credentials, so the setup commands work straight away; `eesel login` afterwards signs you in (or up) and makes that workspace yours, keeping everything in it. An anonymous workspace has $5 of usage and lasts 7 days; a claimed one gets the normal $50 trial and dashboard access. If your account already has a workspace, the login tells you and leaves both alone.

Credentials land in `~/.config/eesel/credentials.json`, readable only by you. To point the CLI at a workspace without a browser (CI, a server), set `EESEL_API_URL` and `EESEL_API_TOKEN` instead; they take precedence over the stored login.

## The five-minute setup

```bash
eesel init chat-bubble --site https://your-site.com   # no account needed
eesel login                                            # keep the workspace
```

`eesel init chat-bubble` picks or creates an agent, adds the chat bubble channel and prints the embed snippet to paste into your site. With a site (`--site`, or the `homepage` field in the repo's `package.json`) the agent also starts reading it, so the bubble answers from your own pages. Plain `eesel init` only picks or creates the agent and connects nothing. Everything is safe to re-run: existing setup is reused, never duplicated.

Then test it without leaving the terminal:

```bash
eesel chat "what does this site do?"
eesel files upload ./refund-policy.pdf
eesel chat "what's our refund policy?"
```

## Chatting with your agent

```bash
eesel chat "how do I reset a password?"   # send one message, stream the reply
eesel chat                                # no message opens the interactive prompt
eesel new --name "refunds"                # start a fresh, named conversation
```

Conversations persist between commands: a plain `eesel chat "..."` keeps talking in the current one. `eesel sessions list` shows them, `eesel sessions use <id>` switches, `eesel sessions show` prints one.

In the interactive prompt, `/new`, `/sessions`, `/agents`, `/show` and `/quit` do what they say.

Anything not listed on this page is something you ask the agent for in chat: searching your knowledge, running an analysis, emailing someone, checking back on something tomorrow.

## Setting up and observing

These are the dashboard's buttons, from the terminal. They're free; only chat is billed work.

```bash
eesel status                                   # what's connected, whether its content is downloaded, your plan
eesel integrations                             # everything the agent is wired to
eesel integrations connect website --url https://your-site.com
eesel integrations connect chat-bubble         # add the chat bubble, print the snippet
eesel integrations connect <platform>          # Zendesk, Freshdesk, Gorgias, Intercom, Slack, ... (one OAuth hop in the browser)
eesel integrations download list               # copy a connected source into eesel knowledge: list, start, status
eesel integrations api check                   # custom API access: check, link, test
eesel automations                              # what the agent does on its own: event, scheduled and webhook automations
eesel instructions                             # read or edit the agent's standing rules
eesel files ls                                 # your files: upload <path>, ls, download <key>
eesel approvals                                # held actions waiting on a human: list, approve <id> [--always], deny <id>
eesel activity                                 # what the agent has been doing, newest first
eesel billing                                  # live billing state, read-only
eesel invite <email>                           # invite a teammate
```

Run any command with `--help` for its full reference.

## Working with several agents

Commands act as one agent. Pass `--agent <id-or-name>` for one invocation, or set a default with `eesel agents use <agent>`. A one-agent workspace needs neither.

```bash
eesel agents                     # the workspace's agents
eesel agents create "Sales bot"  # a new one
eesel agents use "Sales bot"     # make it the default
```

## Using eesel from Claude Code, Cursor or another MCP client

Every workspace is also an MCP server. One command prints everything a client needs, including a ready-to-paste `claude mcp add` line:

```bash
eesel mcp token
```

See [Claude Code & MCP clients](/apis-and-developer-resources/claude-code-and-mcp-clients.md).

## Scripting

| Flag                   | What it does                                                       |
| ---------------------- | ------------------------------------------------------------------ |
| `--agent <id-or-name>` | Act as this agent for one command                                  |
| `--fields a,b.c`       | Keep only these keys in the output                                 |
| `--dry-run`            | Print the exact server call a write would make, without sending it |
| `--help`               | The full reference for a command                                   |

Output is JSON on purpose: single results are pretty-printed, lists are one object per line. Errors are one JSON line on stderr, `{error, hint, retryable}`; exit code 1 is a usage error, 2 a runtime one. The `hint` says what to run instead, which is what makes the CLI usable by an AI agent without a human reading the docs.

Environment variables: `EESEL_API_URL` and `EESEL_API_TOKEN` configure the CLI without a login (this is how the eesel sandbox and CI drive it), and `EESEL_AGENT_ID` picks the agent there.

## If you installed the CLI before September 2026

The earlier `eesel` command was a standalone Python script. It's retired for customer use; the npm package above replaced it. Re-run the install line and log in again. Verbs it had for skills, tasks and workspace settings are now things you ask the agent for in chat, and the CLI tells you the new spelling if you type an old one.

## Common questions

<details>

<summary>Do I need the CLI?</summary>

No. Everything the CLI does can be done in the dashboard. It's for people who'd rather work in a terminal, for scripting, and for letting an AI coding agent do your setup.

</details>

<details>

<summary>Can I use it in CI or a script?</summary>

Yes. Output is already JSON, scope commands with `--agent` or `EESEL_AGENT_ID` rather than relying on a saved default, and use `--dry-run` to check a write before it runs for real.

</details>

<details>

<summary>Is it the same agent as the dashboard?</summary>

Yes, exactly the same. The CLI is another way in, not a separate copy. Changes made either way apply everywhere your agent works.

</details>

## Related

* [Claude Code & MCP clients](/apis-and-developer-resources/claude-code-and-mcp-clients.md) to use your agent from an MCP client
* [Network Access](/apis-and-developer-resources/network-access.md) to let your agent reach your own APIs
* [Automations and Schedules](/automations-and-schedules/automations-and-schedules.md) for triggers and schedules
* The package on [npm](https://www.npmjs.com/package/@eesel/cli)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.eesel.ai/apis-and-developer-resources/cli.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
