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

# Deploy your first API with the dashboard

> Create an agent and its first workflow in the ServFlow visual builder, then call the live endpoint

ServFlow is an agent builder: you define AI agents and the workflows they run, and a Go engine serves them. The dashboard is the visual way to do that — you create an agent, add workflows to it, and wire each workflow up on a canvas.

In this tutorial you'll create an agent, give it a "Hello World" HTTP workflow, and call the endpoint.

<Tip>
  Prefer configuration files? See [Deploy your first API declaratively](/quickstart-declarative). Both produce the same objects.
</Tip>

## Prerequisites

ServFlow Pro running with the dashboard enabled:

```bash theme={null}
servflow-pro start --config config.toml --dashboard
```

If you haven't installed it yet, see [Installation](/installation) — and note that the first time you open the dashboard you'll be asked to complete setup and create an account.

## What you'll build

An agent named `hello-agent` with one workflow that answers `GET /hello-world` with a JSON greeting.

## Step 1: Open the dashboard and sign in

Navigate to:

```
http://localhost:8080/dashboard
```

<Note>
  The dashboard is served under `/dashboard` on the same port as the engine — there is no separate dashboard port.
</Note>

Sign in with the account you created during first run. On a brand-new instance you'll be prompted to complete setup and register instead; see [First run](/installation#first-run-create-your-account).

## Step 2: Create an agent

Agents are the top-level object in ServFlow — a workflow always belongs to one. On the landing screen choose **Create New**.

The **New agent** dialog appears. Fill it in:

1. **Agent name** — enter `hello-agent`
2. Under **New**, choose the option to start **from scratch**

<Tip>
  The same dialog lists **Templates** — prebuilt agents you can start from instead of an empty one. They're the fastest way to see a working multi-workflow agent.
</Tip>

Confirm to create the agent. ServFlow then prompts you to add its first workflow.

## Step 3: Add a workflow

In the workflow dialog:

1. **Name** — enter `hello-world`
2. **Entry type** — choose **API (HTTP)**
3. **Agent** — leave it set to `hello-agent`

The entry type decides how the workflow is reached, and how it is attached to the agent:

| Entry type           | Reached by                  | Attached as |
| -------------------- | --------------------------- | ----------- |
| **API (HTTP)**       | An inbound HTTP request     | Webhook     |
| **Trigger (manual)** | Another workflow calling it | Task        |
| **Scheduled**        | A cron schedule             | Task        |

Since this is an HTTP endpoint, **API (HTTP)** attaches it to the agent as a webhook.

## Step 4: Configure the entry

The workflow opens on the builder canvas with an HTTP entry node already created, pre-filled from the workflow name:

* **Method** — `GET`
* **Listen path** — `/hello-world`

Click the entry node to change either. The listen path is the URL the workflow answers on.

## Step 5: Add a response

Click the **+** button below the entry node. You're offered three kinds of step:

* **Actions** — do work: call an AI model, query a database, make an HTTP request
* **Branch** — route conditionally
* **Responses** — return something to the caller

Choose **Responses**, then configure it:

1. Set the **status code** to `200`
2. Set the response body to:

```json theme={null}
{
  "message": "Hello, World!",
  "status": "success"
}
```

Make sure the entry node connects to this response node — the connection is what makes it run.

## Step 6: Save

Click **Save**. The workflow is stored and served immediately; there's no separate deploy step and no restart.

## Step 7: Call your endpoint

The engine owns the root path, so the workflow answers at its listen path directly:

```bash theme={null}
curl http://localhost:8080/hello-world
```

```json theme={null}
{
  "message": "Hello, World!",
  "status": "success"
}
```

<Check>
  You've built an agent with a live HTTP endpoint.
</Check>

## What you just created

* An **agent** — `hello-agent`, the container that owns this work
* A **workflow** attached to it as a **webhook**, because it has an HTTP entry
* Inside that workflow, an **entry** wired to a **response**

Adding an action between the entry and the response is how a workflow starts doing real work — calling a model, reading a database, or hitting an API.

Everything here is also reachable from the CLI: this agent and workflow can be listed, exported, and edited with `servflow-pro resource`.

## Next steps

<CardGroup cols={2}>
  <Card title="Deploy declaratively" icon="code" href="/quickstart-declarative">
    Define the same workflow as a file and deploy it from the CLI.
  </Card>

  <Card title="Actions" icon="play" href="/concepts/actions/overview">
    Add real work to your workflow.
  </Card>

  <Card title="Running ServFlow" icon="server" href="/running-modes">
    Understand what your instance serves and how to deploy it.
  </Card>

  <Card title="Secrets Management" icon="key" href="/references/secrets">
    Store API keys your agent needs.
  </Card>
</CardGroup>