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

# Atlas Integrations

> Run Atlas through People Intelligence, Bulk Intelligence, workflows, webhooks and MCP, and get structured fields back from an investigation.

Each surface here starts the same investigation, which you can open in the [web app](https://docs.sixtyfour.ai/atlas/web-app.md) or read through the [Atlas API](https://docs.sixtyfour.ai/atlas/api.md).

## People Intelligence

Send a `struct` to [People Intelligence](https://docs.sixtyfour.ai/api-reference/endpoint/people-intelligence.md) with `tier: "xhigh"` and the run returns your fields in `structured_data`, alongside a persistent investigation.

`scout` with `graph: true` runs the same investigation tooling on Scout's lighter model.

Atlas runs take longer than other tiers, so start them with the async endpoint. `GET /v1/jobs/{job_id}` does not return a run's `investigation` yet, so Atlas runs start and poll on the original routes, which keep working:

```bash cURL theme={null}
curl -X POST "https://api.sixtyfour.ai/people-intelligence-async" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "lead_info": {"name": "Jane Doe", "company": "Acme Corp"},
    "struct": {
      "current_role": "Their current job title and employer",
      "board_seats": {"description": "Public board seats they hold", "type": "list[str]"}
    },
    "tier": "xhigh",
    "max_minutes": 60
  }'
```

```python Python theme={null}
import requests

response = requests.post(
    "https://api.sixtyfour.ai/people-intelligence-async",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "lead_info": {"name": "Jane Doe", "company": "Acme Corp"},
        "struct": {
            "current_role": "Their current job title and employer",
            "board_seats": {"description": "Public board seats they hold", "type": "list[str]"}
        },
        "tier": "xhigh",
        "max_minutes": 60
    }
)
response.raise_for_status()
run = response.json()
```

```javascript JavaScript theme={null}
const response = await fetch("https://api.sixtyfour.ai/people-intelligence-async", {
  method: "POST",
  headers: { "x-api-key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    lead_info: { name: "Jane Doe", company: "Acme Corp" },
    struct: {
      current_role: "Their current job title and employer",
      board_seats: { description: "Public board seats they hold", type: "list[str]" }
    },
    tier: "xhigh",
    max_minutes: 60
  })
});
if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const run = await response.json();
```

The start response and every `/job-status` response carry the investigation:

```json theme={null}
{
  "task_id": "enrich_3f8b2c1e-9d4a-4f6b-8c2e-1a7b5d9e0f34",
  "status": "RUNNING",
  "investigation": {
    "id": "29beab70-42e4-5d19-b3b1-9a28279ca19f",
    "workspace_url": "https://app.sixtyfour.ai/atlas/29beab70-42e4-5d19-b3b1-9a28279ca19f/graph"
  }
}
```

Open `workspace_url` to watch the run in the Atlas section of the Sixtyfour app, or read it through the [Atlas API](https://docs.sixtyfour.ai/atlas/api.md) while it is still going.

### Request parameters

Atlas runs take the [People Intelligence parameters](https://docs.sixtyfour.ai/api-reference/legacy/people-intelligence.md#request-parameters), plus:

| Parameter | Type | Default | Description |
| - | - | - | - |
| `graph` | boolean | `false` | With `tier: "scout"`, run Scout as an Atlas run. Any other tier rejects it. |
| `struct` | object | None | Optional on Atlas runs. Without it, the run researches open-endedly into the workspace. |
| `investigation_id` | string | None | Continue an existing investigation. The run reuses its graph and workspace and builds on the earlier research. |
| `investigation_name` | string | derived from `lead_info` | Title for a new investigation. Ignored when `investigation_id` is set. |
| `max_credits` | integer | one unit of the tier price | How much research to buy, from one to ten units of the tier price. |
| `max_minutes` | integer (10 to 1440) | no limit | Working-time limit. When it is reached the run writes up what it found and completes. See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#atlas-investigations) for what it is charged. |
| `relentless` | boolean | `false` | Research until the budget runs out. By default a run with `struct` may stop once every field is answered. |
| `agent_trace` | boolean | `false` | Show a short, readable summary of each agent's reasoning and actions on the investigation's Agents tab in Atlas. It is for people reading along: it doesn't change the research or the results. |
| `generate_report` | boolean | `false` | Start the PDF intelligence report when research completes. You can also generate one any time with [`POST /investigations/{investigation_id}/report`](https://docs.sixtyfour.ai/atlas/api#reports) or from the Report tab in Atlas. |
| `include_workspace` | boolean | `true` | Include the investigation's workspace files with the result. |
| `exclusive_run` | boolean | `false` | Async only. With `investigation_id`, refuse to start a second run while one is running. See [Handling Errors](https://docs.sixtyfour.ai/api-reference/errors.md) for the response. |
| `private` | boolean | `false` | Make the run visible only to you (with an API key, to the key's creator), not your team. Needs private runs enabled for your organization and allowed by your team, the async endpoint, and no `investigation_id`. |
| `connections` | string\[] | every connection | The team's [connections](https://docs.sixtyfour.ai/atlas/connections.md) the run's agents may call, by name. Leave it out for all of them; `[]` for none. |
| `skills` | string\[] | none | [Team skills](https://docs.sixtyfour.ai/atlas/skills.md) every agent of the run follows, as `team/<name>`. |

### Atlas API or People Intelligence

Both start the same investigation, and both take `lead_info`, `struct`, `research_plan`, `max_credits`, `max_minutes`, `dispatch_id` and `private`. Side by side:

| | [Atlas API](https://docs.sixtyfour.ai/atlas/api.md#starting-an-investigation) | People Intelligence with `tier: "xhigh"` |
| - | - | - |
| Start | `POST /v1/atlas/investigations` | `POST /people-intelligence-async` |
| Continue | `POST /v1/atlas/investigations/{investigation_id}/runs` | The same endpoint with `investigation_id` |
| Engine | `engine`: `xhigh` or `scout` | `tier: "xhigh"`, or `tier: "scout"` with `graph: true` |
| Title | `name` | `investigation_name` |
| `relentless` default | `true`: research until the budget runs out | `false`: a run with `struct` may stop once every field is answered |
| `agent_trace` | Not taken: the Agents tab always shows the trace | Taken, default `false` |
| `generate_report` | Not taken: a report starts when each run completes | Taken, default `false` |
| `webhook_url` | Not taken | Taken |
| `field_confidence` | Returned automatically with a `struct`; the option is ignored | Returned automatically with a `struct`; the option isn't needed |
| `include_workspace` | Not taken: results always include `workspace_files` | Taken, default `true` |
| `exclusive_run` | Not taken | Taken, with `investigation_id` |
| Unknown fields | Ignored without a warning | Ignored, and listed in `unrecognized_fields` in the start response |

### Response

Poll `GET /job-status/{task_id}`; [Job status and callbacks](https://docs.sixtyfour.ai/api-reference/legacy.md#job-status-and-callbacks) covers polling and statuses on the original routes. A completed Atlas job's `result` has the [People Intelligence fields](https://docs.sixtyfour.ai/api-reference/endpoint/people-intelligence.md#response), plus:

| Field | Type | Description |
| - | - | - |
| `research_notes` | string | The agents' research notes. |
| `graph` | string | A text rendering of the attribution graph. For structured nodes and edges, use [`GET .../graph`](https://docs.sixtyfour.ai/atlas/api#reading-the-graph-and-workspace). |
| `workspace_files` | object | Map of workspace file paths to their contents. Omitted when `include_workspace` is `false`. |

```json theme={null}
{
  "id": "enrich_3f8b2c1e-9d4a-4f6b-8c2e-1a7b5d9e0f34",
  "status": "completed",
  "investigation": {
    "id": "29beab70-42e4-5d19-b3b1-9a28279ca19f",
    "workspace_url": "https://app.sixtyfour.ai/atlas/29beab70-42e4-5d19-b3b1-9a28279ca19f/graph"
  },
  "result": {
    "structured_data": {
      "current_role": "VP Engineering, Acme Corp",
      "board_seats": ["Example Foundation"]
    },
    "notes": "Confirmed the current role from the company site and a recent filing.",
    "references": {
      "https://acme.example/team": "Leadership page with current title"
    },
    "research_notes": "# Jane Doe\n\nCurrent role confirmed from...",
    "graph": "# Attribution graph\nnodes:\n...",
    "workspace_files": {
      "notes/background.md": "# Background\n\n..."
    }
  }
}
```

These three fields read from the investigation, so a later run on it changes what an earlier job returns. Attachment paths in them come back as permanent `/v1/media` URLs; see [Images and attachments](https://docs.sixtyfour.ai/atlas/api.md#images-and-attachments).

Runs with a `struct` also return `field_confidence`: each answered field has its `confidence`, `justification`, `sources` and the graph `nodes` that support it. See [Confidence Scoring](https://docs.sixtyfour.ai/api-reference/endpoint/field-confidence.md).

### Declined runs

When the agents decline to research a subject, the run ends before any research. The job still reports `completed`: `result.notes` starts with `Declined:` and gives the agents' reason, and `structured_data` repeats your `lead_info` instead of answering your `struct`. A new investigation reads `failed` and gets no report. Check `notes` before you store `structured_data`.

The agents do not research people under 18. When they find the subject is a minor, the run stops at that point, even partway through. Its `notes` start with `Declined: the subject is a minor`, and nothing it found is returned. The run's price is not charged; paid lookups it made before that point still are. The result has no `investigation_id` or `workspace_url`. When the investigation holds nothing but this run's work, it is also removed from the app; an investigation with earlier work is kept.

## Bulk Intelligence

[`POST /bulk-intelligence/people`](https://docs.sixtyfour.ai/api-reference/legacy/bulk-intelligence) accepts `tier: "xhigh"` and runs one investigation per row on the default budget. `graph`, `max_credits`, `max_minutes` and `investigation_id` aren't accepted in bulk config.

To set a budget per lead, start each run from [People Intelligence](#people-intelligence) instead. In the web app, [Upload CSV](https://docs.sixtyfour.ai/atlas/web-app.md#start-one-investigation-per-row) starts one investigation per row with a budget you choose.

## Workflows

Set the tier of an [Enrich People](https://docs.sixtyfour.ai/guides/building-workflows.md) block to **XHigh** to run an investigation for each row. In a workflow definition, set `"tier": "xhigh"` in the `lead_enrichment` block's specs.

Each row creates its own investigation on the default budget, and your return fields become columns. See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#atlas-investigations) for what a row costs. The block also adds:

| Column | What it holds |
| - | - |
| `enrichment_notes` | A short research summary. |
| `enrichment_references` | Maps each source URL to its findings. |
| `enrichment_research_notes` | The agents' research notes. |
| `enrichment_graph` | A text rendering of the attribution graph. |

Place filters before the block so only the rows worth an investigation reach it.

## Webhooks

Pass `webhook_url` to `POST /people-intelligence-async` to receive the [result](#response) when the run finishes. See [Outgoing Webhooks](https://docs.sixtyfour.ai/api-reference/webhooks/outgoing.md).

To follow a run started with `POST /v1/atlas/investigations`, poll [`GET /job-status/{task_id}`](https://docs.sixtyfour.ai/api-reference/legacy#job-status-and-callbacks) or [stream its events](https://docs.sixtyfour.ai/atlas/api.md#following-a-run-live).

## MCP

The [Sixtyfour MCP server](https://docs.sixtyfour.ai/developer-tools/mcp-setup.md) lets a coding assistant start and read investigations. The Atlas tools appear only when your organization has Atlas enabled.

1. `sixtyfour_atlas_start` starts an XHigh investigation on the default budget. Pass the `subject` (any of `name`, `email`, `phone`, `username`, `ip_address`, `profile_url`, `company`, `domain`, or a free-text `query`), a `request_id` as the idempotency key, an optional `objective`, and `private: true` to make the investigation visible only to you.
2. `sixtyfour_atlas_status` polls the task until it finishes.
3. `sixtyfour_atlas_inspect` reads the investigation's summary, or a page of its findings, links or files.
4. `sixtyfour_atlas_file` reads a chunk of a text file that `sixtyfour_atlas_inspect` listed.

`sixtyfour_atlas_list` lists your organization's investigations. The tools read text only, so open the investigation in the web app or use the [Atlas API](https://docs.sixtyfour.ai/atlas/api.md#reading-the-graph-and-workspace) for images and other attachments.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.