> 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/getting-started/set-up-from-a-coding-agent.md).

# Set up from Claude Code or the terminal

Set up eesel from Claude Code or the terminal: step-by-step commands for a website chat bubble, a helpdesk AI agent or a Slack teammate, with optional sign-in for a new trial.

You can use the dashboard for hands-on setup, or use [eesel CLI](/apis-and-developer-resources/cli.md) to operate eesel programmatically. It gives you and your coding agent commands to connect supported apps, add knowledge, retrieve a chat bubble's embed code and manage automations in the same workspace.

If you are starting from a terminal without eesel MCP connected, use the CLI and follow this guide for the user's requested eesel task. If eesel MCP is already connected to the intended workspace, use it for the supported steps. Keep the task within the user's authorization: account admins still approve external connections, and action permissions and approvals still apply. Some integration guides require a dashboard form or file picker.

Before you start:

* **Use the intended workspace.** Start with `npx @eesel/cli whoami`. With a stored login, sign in if needed with `npx @eesel/cli login`, list agents with `npx @eesel/cli agents`, then choose one with `npx @eesel/cli agents use <id-or-name>` or `--agent <id-or-name>`. Confirm the workspace before writing.
* **Check environment credentials.** If `whoami` reports environment configuration, it takes precedence over stored login. Use the intended `EESEL_AGENT_ID` or `--agent <full-uuid>`. `init` and `files upload` cannot use an environment token: they use a stored browser login or anonymous session, and `init` can create that anonymous session. `agents create` and the direct website or chat-bubble connect commands need a browser login. Follow each command's error hint. Do not change workspaces just to get past an error.
* **A new trial can start without login.** With no stored credentials, `npx @eesel/cli init chat-bubble --site https://example.com --json` creates an anonymous workspace. For another task, plain `npx @eesel/cli init` creates an agent without adding a bubble or connecting sources. Read the expiry from the receipt. `eesel login` later tries to keep it; if the account already has a workspace, read the claim result rather than assuming the trial moved into that workspace.
* **Check actual results.** A connection receipt, a started download and a visible widget are different milestones. Use the returned IDs, snippets and URLs, check knowledge availability, and test an answer in the requested channel. Helpdesk and Slack work also need the intended automation enabled.

## Install

Nothing to install. Node.js 18.17 or newer, and `npx @eesel/cli <command>` runs it. The rest of this page writes `eesel ...` for short; use `npx @eesel/cli ...` for any command, or run `npm install -g @eesel/cli` to put `eesel` on your PATH.

## Job 1: a chat bubble on a website

The bubble answers visitors from the site's own pages and help center, cites the page it used, and hands off to a person when it should. Replace `example.com` below with your actual public site URL; reserved example domains are rejected when connecting website knowledge. One command, no account:

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

With no stored login, this creates an anonymous workspace and its agent, adds the chat bubble channel, and starts a chat asking eesel to connect and learn the site. The JSON receipt includes:

* `agent_id` and `trigger_id`: the actual agent and channel created or reused.
* `snippet`: the embed code to install, with the real trigger id already filled in.
* `public_chat_url`: a hosted link for trying this bubble's agent before installation.
* `learn_site_task_id`: the setup conversation to follow. A null value means the learning chat did not start; ask `eesel chat` to connect and learn the requested site.
* `credential_type`, `anonymous_expires_at` and `keep_it`: the account state, trial expiry and command for keeping the workspace.

For an anonymous workspace, tell the person when it expires and how to keep it. `eesel login` opens the sign-in page and asks them to authorize the CLI. Read `claimed_anonymous_workspace` in the login output: if the account already owns another workspace, the trial is left separate and the CLI switches to the account's workspace. Check `eesel whoami` and the agent again before continuing. Use `--no-browser` to print a link they can open on another machine.

On a machine that already has a login, the same command uses the workspace's default agent (or its only one, or creates one if there is none; `--new-agent` forces a fresh one, `--agent <name>` picks).

Paste the snippet into the site's HTML before `</body>`. In a Next.js app, put the trigger id in `.env.local` (and the host's environment) as `NEXT_PUBLIC_EESEL_TRIGGER_ID` and render the snippet once in the root layout; the exact code is on the [Chat bubble](/integrations/chat-surfaces/chat-bubble.md) page, along with Shopify, WordPress and other placements. The snippet makes the bubble appear; it does not prove that the site has been learned. Follow the setup conversation with `eesel chat --task <learn_site_task_id> "What site content is available, and did the crawl start?"` when that id is present. Check `eesel status` and `eesel integrations download status <site-url>` for the content that has arrived.

Use the returned `snippet` as-is. Do not invent a trigger id or ask the person to find one when the CLI has already returned it. On a preview of the site, open the installed bubble and ask a question whose answer is on a known page. Check the answer and its source; rendering the bubble alone is not a successful test. You can also test the agent from the terminal:

```bash
eesel chat "what does this site sell, and what is the returns policy?"
eesel files upload ./returns-policy.pdf      # anything the site doesn't say
```

For a store, connect Shopify so the bubble can look up orders and products and act as a sales rep:

```bash
eesel integrations connect shopify           # shows the ways to connect and what each needs
```

The full connection needs the store owner to approve it in Shopify. Use the link the command returns; if it returns a held receipt with no link, ask for one with `eesel chat "give me the connect link for shopify"`. After the approval, `eesel status` shows Shopify connected and the bubble can recommend products, check stock and look up orders. What it may *do* (refund, cancel, create a draft order) is a permission per action; see [Actions and approvals](/instructions-and-memory/actions-and-approvals.md).

## Job 2: an AI agent inside the helpdesk

Works the same for Gorgias, Zendesk, Freshdesk and Intercom. Gorgias shown:

```bash
eesel integrations connect gorgias
```

That lists the ways to connect and the `--param` values each needs. `quick-start` reads the public help center only and completes immediately, no approval needed. `full` connects the account: a person opens a link and approves it in the browser, and after that the agent can read tickets and macros, react to ticket events and act on tickets. Use the link the command returns. If it returns a held receipt with no link (`waiting_for_approval`), the connection has not started; ask the agent for the link instead: `eesel chat "give me the connect link for gorgias"`. Don't wait for the click in a loop. Move on, and confirm later with `eesel status`, which lists every connected tool with its connection health.

```bash
eesel integrations connect gorgias --method full --param gorgiasSubdomain=acme   # the listing above names the params
eesel status
```

Give it the knowledge:

```bash
eesel integrations sources gorgias                      # help center, macros, tickets: which are downloadable, and how many documents each has so far
eesel integrations download start gorgias --type tickets      # starts in the background and returns at once
eesel integrations download status gorgias              # indexed document counts; done when the status says so, not when the start command returns
```

A first ticket download usually takes minutes, not seconds. The agent can already answer from what has landed.

Tell it how to behave by asking it in chat. The agent writes its own instructions, so a new rule fits with what it already has; `eesel instructions` shows the result:

```bash
eesel chat "Add to your instructions: escalate (internal note, assign to a human, do not reply) when the customer is upset, asks for a manager, or a refund is over \$100."
eesel instructions
```

Then make it act. An automation is an event in the helpdesk plus instructions for that one job. Nothing happens on a ticket until one is on, and once it is on it runs on every matching ticket from then on, which is why the first version below only drafts:

```bash
eesel automations list gorgias                          # the events this helpdesk offers, with their keys and whether each is on
eesel chat "Set up a Gorgias automation: when a customer messages, draft a reply as an internal note for a human to review. Skip anything tagged spam."
```

Creating an automation or changing its instructions or filter goes through `eesel chat`, the same as the agent's own instructions, because that is text the agent reads. Its settings change directly: `eesel automations update <app> <key> --enabled false` (or `true`) pauses or resumes one that exists, and `--model-tier` or a schedule's `--cron` work the same way. When the drafts are good, ask in chat to change the automation so it replies directly on routine cases and keeps drafting the rest. Separately from instructions, each action (reply, tag, refund) is set to run on its own, ask a person first, or off; see [Actions and approvals](/instructions-and-memory/actions-and-approvals.md). CLI requests keep the workspace role and action approval rules. Read the receipt to see whether a change ran or is waiting; `eesel approvals` lists pending action decisions. A coding agent should leave those decisions to the authorized person unless the user has explicitly authorized it to make that decision. If `eesel integrations connect` answers that it's waiting for approval, that one may not appear there; confirm it with `eesel status` rather than retrying.

Before going live, have the agent test itself on past tickets. This is a sentence to the agent, not a command with a fixed output; the reply is its report, listing the tickets it would have answered differently and why:

```bash
eesel chat "run a simulation on our last 100 tickets and tell me what you would have got wrong"
```

Trigger keys and details per helpdesk: [Gorgias](/integrations/helpdesks/gorgias.md), [Zendesk](/integrations/helpdesks/zendesk.md), [Freshdesk](/integrations/helpdesks/freshdesk.md), [Intercom](/integrations/helpdesks/intercom.md).

## Job 3: a teammate in Slack

```bash
eesel integrations connect slack             # a person approves this in Slack: use the link it returns, or ask eesel chat for one
```

After approval, the person invites the app to the channels it should answer in (`/invite @eesel` in Slack). Give it the knowledge, from files or the tools the company already uses:

```bash
eesel files upload ./handbook.pdf
eesel integrations connect                  # what this workspace can connect, and how
eesel integrations connect google-drive
eesel integrations connect confluence_v2
```

Run `eesel integrations connect` with no arguments first: it lists what this workspace can connect and the methods each offers. Where a method says to set it up from the eesel dashboard, that is the route; use the dashboard or `eesel chat`, not a guessed `--method`. Notion is one of those today. Google Drive needs its dashboard file picker, Notion needs explicit page sharing, and the current Confluence connection needs an Atlassian API token entered securely. Follow each integration guide; do not assume one app's connection method applies to another. Then ask for the mention automation:

```bash
eesel chat "Set up the Slack mention automation: answer from our docs and cite the page. If you can't find it, say so and suggest who to ask."
```

From then on, @eesel in a channel it is in gets an answer in the thread. It can also act across the company's connected apps when asked in Slack (create a Jira ticket, update a helpdesk ticket, email someone). What it may do, and what needs a person's approval first, is the same setting per action as everywhere else. Who in Slack may change its instructions is covered on the [Slack](/integrations/communication/slack.md) page: workspace editors teach it, everyone else gets answers.

## Anything else: ask the agent

The commands above cover setup and checking on things. Everything else, including reports, analysis, one-off tasks and "check back tomorrow", is a sentence to the agent:

```bash
eesel chat "which questions did the bubble fail to answer this week?"
```

`eesel chat` continues the current conversation; `eesel new` starts another. If `eesel chat` returns nothing, the current conversation has hit an error: run `eesel new` and ask again. A reply that says an action is waiting for approval means a person has to decide, in the dashboard, in the Slack thread, or with `eesel approvals approve <id>`; do not retry it.

## Use eesel from an MCP client instead

Every workspace is also an MCP server. `eesel mcp token` prints the URL, the token, the headers and a ready `claude mcp add` line. See [Claude Code & MCP clients](/apis-and-developer-resources/claude-code-and-mcp-clients.md). For claude.ai, ChatGPT and other assistants, see [Use eesel from Claude and other AI assistants](/apis-and-developer-resources/use-eesel-from-claude-and-other-assistants.md) and [Use eesel from ChatGPT](/apis-and-developer-resources/use-eesel-from-chatgpt.md).

## What it costs

Setup commands are free; the agent's work follows the plan and allowance for the workspace. A trial has a limited allowance. Check the returned trial details and [Pricing](/pricing/overview.md) before running customer conversations or a large test.

## FAQ

<details>

<summary>Can Claude Code set up eesel for me?</summary>

Yes. Coding agents with terminal access can follow this guide to connect supported apps, add knowledge, retrieve and install the real bubble snippet, and check automations. A new trial can start without login. Existing-workspace selection, external authorization, any required dashboard forms and action approvals still apply.

</details>

<details>

<summary>Do I need an eesel account before I start?</summary>

No, for a new trial. With no stored credentials, `eesel init` creates an anonymous workspace. If you want to use an existing workspace, sign in and confirm it first. A later login tries to claim the anonymous workspace; read its result, especially when the account already has a workspace.

</details>

<details>

<summary>How do I add an eesel chat bubble to my website from the terminal?</summary>

Run `eesel init chat-bubble --site https://example.com` and paste the snippet it prints into your site's HTML before `</body>`. The bubble is live as soon as the snippet is on the page. See [Job 1](#job-1-a-chat-bubble-on-a-website).

</details>

<details>

<summary>Will the agent reply on tickets as soon as I connect my helpdesk?</summary>

Connecting the account alone does not make it reply. Check existing automations before changing anything; an enabled automation can already act on matching events. In a new setup, create the intended automation when you are ready. A newly created chat bubble can answer as soon as its snippet is installed.

</details>

<details>

<summary>What if the connect command returns no link?</summary>

Ask the agent for one with `eesel chat "give me the connect link for <app>"`. Don't retry the connect command or wait for the click in a loop. Move on, and confirm later with `eesel status`.

</details>

<details>

<summary>Can I test the agent before customers see it?</summary>

Yes. `eesel chat` asks your agent a question from the terminal, and you can ask it to run a simulation on your past tickets before any automation goes live.

</details>

## Reference

* [The eesel CLI](/apis-and-developer-resources/cli.md), every verb
* [Chat bubble](/integrations/chat-surfaces/chat-bubble.md), the snippet and framework notes
* [Actions and approvals](/instructions-and-memory/actions-and-approvals.md)
* [Automations and Schedules](/automations-and-schedules/automations-and-schedules.md)
* [Instructions and Memory](/instructions-and-memory/instructions-and-memory.md)
* [Use eesel from Claude and other AI assistants](/apis-and-developer-resources/use-eesel-from-claude-and-other-assistants.md) and [Use eesel from ChatGPT](/apis-and-developer-resources/use-eesel-from-chatgpt.md)


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.eesel.ai/getting-started/set-up-from-a-coding-agent.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.