> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zelto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Onboard with an agent

> Have your coding agent onboard your organization onto Zelto end to end over MCP — connect a provider, get calls in, create a monitor, and route findings.

If you already run an AI coding agent — Claude Code, Cursor, Codex, or
similar — it can stand up your Zelto organization for you over the
[MCP server](/docs/mcp): connect a call provider, create a monitor, wait
for the first [finding](/docs/findings), and set up delivery. This page is
both the human walkthrough and the script the agent follows (it reads the
same steps through the `read_docs` tool).

## Before you start

The one thing the agent can't do for you is bootstrap its own access:

1. **Mint an API key** at **Settings → Integrations → API Call Upload** in
   the dashboard. It's shown once — copy it.
2. **Connect the Zelto MCP server** in your editor with that key — see
   [MCP](/docs/mcp) for the per-client config. Confirm with the `health`
   tool (it returns your org id).

Everything below runs against the [onboarding tools](/docs/mcp#onboarding)
on that connection.

## The flow

<Steps>
  <Step title="Check where you are">
    The agent calls `get_onboarding_status` first. It returns the ordered
    setup steps — connect a provider, create a monitor, receive a first
    finding, set up delivery — each with a `done` flag, plus
    `nextIncomplete`. Re-running onboarding is safe: the agent resumes from
    the first incomplete step.
  </Step>

  <Step title="Connect a call provider">
    The agent calls `list_integrations` to see what's already connected,
    asks which stack you run, then `connect_integration` with the
    `provider` (`vapi`, `retell`, `speechify`, `telnyx`, or `elevenlabs`)
    and your provider `apiKey`. The key is validated against the provider
    and stored encrypted.

    For **Vapi**, **Retell**, and **Speechify**, the response includes a
    `webhook.webhookUrl` you paste into that provider's dashboard — the one
    step only you can do. **ElevenLabs** and **Telnyx** sync automatically,
    no webhook needed.
  </Step>

  <Step title="Get calls flowing">
    Calls arrive once the webhook is pasted (or the hourly sync runs for
    the pull-based providers). The agent polls `list_conversations` until
    the first call lands. On a first call, Zelto creates the
    [agent](/docs/agents) automatically. Already have history in a connected
    Retell account? The agent can import it with `retell_import_agent` and
    `retell_import_conversations` instead of waiting.
  </Step>

  <Step title="Create a monitor">
    A [monitor](/docs/monitors) is an AI judge that runs against every call
    and flags the ones that match a rubric. The agent offers the
    ready-made catalog from `list_starter_monitors` (refusals, task failure,
    user frustration, and more), then calls `create_monitor` — either with a
    `starterKey`, or with a `name` and a plain-language yes/no `instruction`
    of your own. It confirms with `list_monitors`.
  </Step>

  <Step title="Wait for the first finding">
    As calls flow through the monitor, Zelto surfaces
    [findings](/docs/findings) — durable, org-level issues grouped from the
    calls that matched. The agent polls `list_findings` (or watches the
    `firstFinding` flag on `get_onboarding_status`) until the first one
    appears.
  </Step>

  <Step title="Route findings to your team">
    Finally the agent calls `set_findings_delivery` with the `channels` you
    want — `email` and/or `slack`. Slack additionally needs the Slack app
    connected via OAuth under **Settings → Integrations**, which the agent
    will flag for you to do.
  </Step>
</Steps>

## Use your coding agent

Paste the prompt below into the coding agent in your editor. It loads the
`zelto-onboarding` skill if your client supports Anthropic Agent Skills, or
falls back to reading this page through `read_docs` — either way it follows
the flow above and pauses for the steps only you can do.

<div className="prompt-scroll">
  ```text title="Paste into your coding agent" theme={null}
  You are onboarding my organization onto Zelto, a production analytics platform
  for voice and chat AI agents, over its MCP server. Drive the whole setup: connect
  a call provider, get calls flowing, create a monitor, wait for a first finding,
  and set up findings delivery.

  Prerequisite (already done): the Zelto MCP server is connected in this editor with
  my org's API key. Confirm with the `health` tool before anything else; if it
  fails, stop and tell me to mint a key and connect the server (see the MCP guide).

  Follow the authoritative steps, in order:
  - If you support Anthropic Agent Skills, load the `zelto-onboarding` skill and
    follow it.
  - Otherwise call the `read_docs` tool with path `onboarding-with-an-agent` and
    follow that page step by step.

  Rules:
  - Every write tool returns JSON that may contain an `error` key — always check it.
    A non-error return means "accepted", not "done": writes settle asynchronously,
    so confirm each step with the paired read tool (e.g. list_conversations after
    connecting, list_monitors after creating) before moving on.
  - Never fabricate an API key, webhook URL, or id — read them from tool output or
    ask me. When a step needs me (pasting a webhook URL into a provider dashboard,
    Slack OAuth), stop and tell me exactly what to do, then verify before continuing.
  - Start by calling get_onboarding_status and resume from the first incomplete step.
  ```
</div>

## Install the skill

Three ways to give your agent the skill, lowest-friction first:

1. **Zero-install (works with any MCP client).** Every connected editor
   already has the `read_docs` tool — the paste-prompt above tells the
   agent to `read_docs('onboarding-with-an-agent')` and follow it. This
   always reflects the live version of this page. Recommended.
2. **Copy the skill folder (Claude Code and other Skills-capable clients).**
   Drop the `zelto-onboarding` skill folder into your agent's skills
   directory (for Claude Code, `.claude/skills/`). The skill's `SKILL.md`
   plus its `references/` files drive the same flow with progressive detail.
3. **Reference it inline.** Point the agent at this page's URL in your own
   prompt; it will `read_docs` the current version on demand.

## Related

* [MCP](/docs/mcp) — connect the server and the full [onboarding tools](/docs/mcp#onboarding) reference.
* [Quickstart](/docs/quickstart) — the same setup done by hand in the dashboard.
* [Connect a voice provider](/docs/integrations) — per-provider connection details.
* [Findings](/docs/findings) — what Zelto surfaces once your monitor is live.