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

# Conductor (Agent / MCP)

> Drive the whole Timepoint stack from one endpoint — the Conductor over REST and MCP, with a natural-language converse tool, token auth, and spend-aware responses.

# Conductor — Agent & MCP Usage

The **Timepoint Conductor** lets an agent operate the entire stack — Flash, Pro, Clockchain, Find Money, Billing, TDF, and more — from a single endpoint, in natural language. Instead of wiring up each service's API, an agent sends one plain-language request and the Conductor routes, runs, monitors, and reports back.

It is available two ways:

| Surface  | Endpoint                                                           | Use it for                                                             |
| -------- | ------------------------------------------------------------------ | ---------------------------------------------------------------------- |
| **REST** | `POST https://conductor.timepointai.com/api/v1/conductor/messages` | Server-side integrations, your own chat UI.                            |
| **MCP**  | `https://conductor.timepointai.com/mcp` (Streamable HTTP)          | Any MCP-capable agent (Claude and others) driving the stack as a tool. |

<Note>
  Every Conductor request is routed through the [API Gateway](/api-reference/overview), so it inherits Timepoint's central authentication and credit/spend metering. You authenticate with a standard Timepoint token (Bearer JWT) — see [Authentication](/api-reference/authentication).
</Note>

## Authentication

Pass your Timepoint token in the `Authorization` header, exactly as you would for any gateway-routed call:

```
Authorization: Bearer YOUR_TIMEPOINT_JWT
```

The Conductor resolves the caller (user, balance, and capabilities) from the token. No separate Conductor credential is required.

## REST

Send a message; get back the Conductor's reply plus metadata about what it did and what it spent.

```bash theme={null}
curl -X POST https://conductor.timepointai.com/api/v1/conductor/messages \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TIMEPOINT_JWT" \
  -d '{"content": "Render the moment AlphaGo played Move 37 against Lee Sedol, then tell me what it cost."}'
```

## MCP — the `converse` tool

Point an MCP client at the endpoint and call the `converse` tool. This is the "drive the whole stack from one endpoint" surface: one natural-language string in, a structured reply out.

```json theme={null}
{
  "mcpServers": {
    "timepoint-conductor": {
      "url": "https://conductor.timepointai.com/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer YOUR_TIMEPOINT_JWT"
      }
    }
  }
}
```

Call `converse` with your request in natural language:

```json theme={null}
{
  "tool": "converse",
  "arguments": {
    "content": "Find $50k in grants for a regional arts nonprofit by September, screen them, and run a Pro simulation on the best three."
  }
}
```

## Response shape

A Conductor response carries three things: the natural-language **reply**, the **tools it called** along the way, and the **spend** it incurred. Spend is reported as a stream of *chirps* — one per tool call — plus a running total, because the Conductor is credit-aware and meta-aware by design.

```json theme={null}
{
  "reply": "I sourced 14 grant opportunities, quick-simulated each, screened down to the 5 strongest, and ran a deep Pro simulation on your top 3. Here are the leads ranked by probability of award...",
  "tools_called": [
    { "tool": "find_money_run",   "credits": 30, "running_total": 30, "note": "sourced + quick-sim 14 opportunities" },
    { "tool": "find_money_select","credits": 0,  "running_total": 30, "note": "auto-selected top 5" },
    { "tool": "pro_simulate",     "credits": 45, "running_total": 75, "note": "deep-sim on 3 leads" }
  ],
  "spend": {
    "credits_total": 75,
    "running_total": 75
  }
}
```

<Note>
  Field names are illustrative. The contract is stable in shape — a `reply`, the sequence of tools the Conductor called, and per-call plus total credit spend — so an agent can render progress and budgets as the work proceeds.
</Note>

## What the agent can drive

Through the Conductor, an agent can reach every product surface in plain language:

| Surface        | Examples                                                              |
| -------------- | --------------------------------------------------------------------- |
| **Flash**      | Render a grounded historical moment, generate imagery.                |
| **Pro**        | Configure and run a deep simulation; compare strategies.              |
| **Clockchain** | Search the graph, fetch a moment and its causal neighbors.            |
| **Find Money** | Run the full flow — source, quick-sim, screen, deep-sim — end to end. |
| **Billing**    | Check balance and what recent work cost.                              |
| **TDF**        | Return results as rich, TDF-native renders.                           |

The Conductor handles the orchestration: routing, running long jobs to completion, recovering from failures, and reporting spend the whole way.

## Behavior controls

Each account's Conductor is tuned through a fixed set of options — autonomy, verbosity, spend ceiling, and default render — that shape how it makes choices, how much it narrates, the per-request credit budget at which it pauses, and whether replies come back as text or rich renders. See [Tuning your Conductor](/products/conductor#tuning-your-conductor).

## Related

<CardGroup cols={2}>
  <Card title="Conductor — Product" icon="wand-magic-sparkles" href="/products/conductor">
    What the Conductor is and what you can ask it.
  </Card>

  <Card title="Authentication" icon="key" href="/api-reference/authentication">
    Timepoint token types and how to obtain one.
  </Card>
</CardGroup>