---
title: Quick start
description: Start in the Agents tab, or call a saved Format over the Developer API.
---

Two entry paths: work with the agent in the **Agents** tab, or call a saved
Format over the **API**. Most teams do both — author in Agents, then invoke the
recipe from their backend.

New to the product map? Read [Sume basics](/the-basics) first — Agents, Formats,
Models, and which surface is primary for partners.

Deep guides: [Format API](/formats) · [Calling a Format](/formats/call) ·
[Agents overview](/agents) · [Models overview](/models).

<!-- quick-start-options:start -->

Agents

## Option 1: Start it from one brief

Paste this into the composer at [sume.com/agents](https://www.sume.com/agents).
The thread keeps every artifact and approval.

```text
Make me a 15-second vertical product promo for my product. Use a presenter
avatar, add captions, and show me a draft before spending credits on the final
render. Once I approve it, save this thread's recipe as a Format called
product-promo so I can call it from my backend.
```

## Option 2: Work the thread

Use the Agents tab when a person should stay in the loop: brief, review,
iterate, then save the result as a reusable recipe.

1. Open the Agents tab

Sign in and start a thread. Nothing to install.

```text
https://www.sume.com/agents
```

2. Brief the agent

Describe the deliverable, not the tool calls. The agent picks the models, and
asks before it spends.

```text
Make a 15-second vertical product promo with a presenter avatar and captions.
Show me a draft before the final render.
```

3. Save the recipe as a Format

A Format is the same thread's recipe, addressable by handle and slug — that is
what your backend calls later.

```text
Save this as a Format called product-promo.
```

Next: [Agents overview](/agents).

API

## Option 1: Start it with your agent

Paste this into an agent that can edit or run your server-side integration code.

```text
Call a Sume Format from my server environment. Use SUME_API_KEY for auth and
POST https://api.sume.com/v1/formats/{handle}/{slug}/runs with a JSON body of
{"instruction": "..."} plus an Idempotency-Key header. The call returns 202 with
a run receipt; poll status_url until the run leaves queued/running, then read
result_url and return the artifacts and any structured output. If SUME_API_KEY
is missing, ask me to create one at https://www.sume.com/dashboard/api-keys with
the formats:read and formats:write scopes.
```

## Option 2: Use it manually

Use the API when your backend should run a saved Format directly — one call
carries the orchestration you would otherwise write yourself.

1. Create your API key in the **[API Keys dashboard](https://www.sume.com/dashboard/api-keys)**
   with the `formats:read` and `formats:write` scopes, then export it:

```bash
export SUME_API_KEY="sume_live_..."
```

2. Start a Format run. Call it by handle and slug — the same address its detail
   page shows. An accepted run returns `202` with a receipt:

<!-- api-call-example:format-vanity-run -->

3. Read the result. Poll `status_url` until the run leaves `queued` / `running`,
   then read `result_url`:

```bash
curl -sS https://api.sume.com/v1/format-runs/run_.../status \
  -H "Authorization: Bearer $SUME_API_KEY"
```

In production prefer a [webhook](/sdk/webhooks) over polling, or let the
[TypeScript SDK](/sdk/runs) do the waiting.

Next: [Calling a Format](/formats/call).

<!-- quick-start-options:end -->

Need a single model call instead of a packaged workflow? Go straight to
[Create new avatar](/models/avatar), [Image 1.0](/models/image), or the
[API recipes](/api/cookbook).