> 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

Step-by-step commands for an AI coding agent or a terminal to set up eesel: a website chat bubble, an agent inside a helpdesk, or a teammate in Slack, with one browser sign-in as the only human step.

eesel gives a company an AI agent that answers customers on its website and in its helpdesk, and answers the company's own team in Slack, using the company's real content. If you are an AI coding agent doing the setup for someone, this page is the job, in commands. The dashboard stays optional: approvals and the bubble's colours can be handled there, but nothing below needs it.

Three things to know before you start:

* **No account needed to start.** The first command creates a free anonymous workspace on the spot: $5 of usage, 7 days, no sign-up. `eesel login` later keeps it (one browser step, full $50 trial, dashboard access). Connecting a helpdesk, Shopify or Slack needs a person to approve it once, in that tool. Everything else runs where you are.
* **Two kinds of channel.** The website chat bubble is live the moment it's added, because customers come to it. In a helpdesk or Slack the agent only acts when an automation tells it to, so you can connect everything and nothing happens until you say so.
* **Every command prints JSON**, and every error is one JSON line on stderr with a `hint` that says what to run instead. Commands are safe to re-run: existing setup is reused, never duplicated.

## 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; `curl -fsSL https://dashboard.eesel.ai/eesel-cli/install | sh` puts an `eesel` command on the PATH that does the same.

## 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. One command, no account:

```bash
eesel init chat-bubble --site https://example.com
```

With no stored login that creates an anonymous workspace and its agent, starts the agent reading the site, adds the chat bubble channel and prints three things: the embed snippet with the bubble's trigger id already in it, the trigger id on its own, and a hosted chat link for trying the agent before the snippet is live. Add `--json` for a machine-readable receipt. It ends with:

```
This workspace is anonymous: $5 of free usage, expires in 7 days.
  keep it (free $50 trial, dashboard access):   eesel login
```

Tell the person that line. `eesel login` opens the browser once: the eesel sign-in page takes their email and signs them in or up by emailed code, password or Google, then an Authorize button hands the session to the CLI. The workspace they set up from the terminal becomes their account's, with everything in it. Add `--no-browser` when there is no browser where you are running: it prints the link for them to open on their own 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 bubble is live as soon as the snippet is on the page.

Then test it before anyone else sees it:

```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 gorgias download --type tickets      # starts in the background and returns at once
eesel integrations gorgias download status              # 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, in plain text, in its instructions:

```bash
eesel instructions
eesel instructions insert --at end --text "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."
```

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 automations enable gorgias gorgias_ticket_commented --instructions "When a customer messages, draft a reply as an internal note for a human to review. Skip anything tagged spam."
```

When the drafts are good, change the instructions 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). Your own writes such as an instruction edit or an automation run straight away, on a logged-in workspace or an anonymous one. An action is held only when it is set to ask a person first; anything waiting shows up in `eesel approvals`, and `eesel approvals approve <id>` decides it, on any kind of login. 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
```

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 and Confluence let the person choose which folders or spaces to share, inside that tool. Then turn the mention trigger on:

```bash
eesel automations enable slack slack_eesel_mentioned --instructions "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, `eesel chat` and dashboard questions are free. The agent is billed per task it does for real people: a support ticket or a bubble conversation is $0.40 however many messages it has, a blog post is $4.00. New workspaces start with $50 of free usage and no card, so nothing on this page can run that out. Full detail on [Pricing](/pricing/overview.md).

## 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)


---

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