# Agent Profiles

# Reference: Agent profiles

The Generic Agent Runner exposes a set of registered profiles. Each profile is a declarative record pairing a system prompt with a tool kit and a target deliverable. Callers select a profile by id via `agents.start`; the runner loads the profile, renders the prompt against the task context, and drives the Anthropic tool-use loop.

This page is the canonical catalog of every profile currently registered on the platform. The profiles registered on the platform are the source of truth; if this doc disagrees, the platform wins and this doc is a bug.

## At a glance

| Profile id       | Model               | Max turns | Temperature | Produces artifact type |
| ---------------- | ------------------- | --------- | ----------- | ---------------------- |
| `content_writer` | `claude-sonnet-4-6` | 25        | 0.3         | `content_piece`        |
| `researcher`     | `claude-sonnet-4-6` | 20        | 0.2         | `research_report`      |
| `copilot`        | `claude-sonnet-4-6` | 15        | 0.4         | none (optional)        |
| `orchestrator`   | `claude-sonnet-4-6` | 50        | 0.2         | none (planning)        |

All four profiles are version `1.0`.

## `content_writer`

End-to-end content creation. Researches the topic (only when the caller has not pre-supplied research), outlines via content tools, writes a full draft, evaluates quality, and finalizes an artifact of type `content_piece` (or a more specific subtype such as `linkedin_post` or `blog_post` when `input_params` strongly implies one).

### Config

- **id**: `content_writer`
- **version**: `1.0`
- **name**: `Content Writer`
- **description**: End-to-end content creation agent. Researches, outlines, writes, and evaluates content. Produces a `platform_artifact` of type `content_piece`.
- **model**: `claude-sonnet-4-6`
- **temperature**: `0.3`
- **maxTurns**: `25`
- **producesArtifactType**: `content_piece`

### Tool ids (glob-expanded at runtime)

```
content.*
data.*
context.*
context_substrate.*
context_entries.*
artifacts.create
artifacts.update
knowledge_base.search
```

### Input params

| Field                    | Type     | Notes                                                                  |
| ------------------------ | -------- | ---------------------------------------------------------------------- |
| `project_id`             | string   | Optional project uuid for scoping.                                     |
| `channel`                | string   | `"blog"`, `"linkedin"`, `"newsletter"`, etc.                           |
| `content_type`           | string   | More specific than channel. `"blog_post"`, `"linkedin_post"`.          |
| `audience`               | string   | Persona description.                                                   |
| `voice_profile_id`       | string   | UUID of a voice profile to match tone.                                 |
| `reference_document_ids` | string[] | Knowledge base doc ids the agent should treat as primary source.       |
| `reference_doc_only`     | boolean  | If true, skip external research and ground only in the reference docs. |

### Use case examples

- Draft a blog post on a topic grounded in internal research.
- Write a LinkedIn post in a specific voice with cited sources.
- Produce a newsletter issue from a supplied set of reference documents.

### Sample `agents.start`

```json
{
  "profile_id": "content_writer",
  "task": "Write a 900-word blog post on how mid-market SaaS teams evaluate data quality tooling.",
  "input_params": {
    "channel": "blog",
    "content_type": "blog_post",
    "audience": "VP Data at mid-market SaaS",
    "voice_profile_id": "22222222-2222-2222-2222-222222222222"
  },
  "async": true
}
```

## `researcher`

Deep research agent. Explores a topic against the business's internal substrate and knowledge base, synthesizes findings with citations, and finalizes one artifact of type `research_report`. Scoped narrower than `content_writer`: no content tools, no artifact updates. Read-heavy.

### Config

- **id**: `researcher`
- **version**: `1.0`
- **name**: `Researcher`
- **description**: Deep research agent. Explores topics against substrate + knowledge base, synthesizes findings with citations, and produces a `research_report` artifact.
- **model**: `claude-sonnet-4-6`
- **temperature**: `0.2`
- **maxTurns**: `20`
- **producesArtifactType**: `research_report`

### Tool ids

```
data.*
context.*
context_substrate.query
knowledge_base.search
knowledge_base.chat
artifacts.create
```

### Input params

| Field                    | Type     | Notes                                                             |
| ------------------------ | -------- | ----------------------------------------------------------------- |
| `project_id`             | string   | Optional project uuid for scoping.                                |
| `audience`               | string   | Persona or audience lens for the synthesis.                       |
| `depth`                  | string   | Free-form depth hint. Example: `"quick"`, `"thorough"`.           |
| `reference_document_ids` | string[] | Starting set of knowledge base doc ids to seed the investigation. |
| `must_cover`             | string[] | Sub-questions the agent must not drop from the final report.      |

### Use case examples

- Produce a competitive briefing on a specific company or segment.
- Synthesize a cross-doc answer grounded in a customer-interview library.
- Run a deep dive on a product area to seed a later content run.

### Sample `agents.start`

```json
{
  "profile_id": "researcher",
  "task": "Research how mid-market SaaS teams currently evaluate data quality tools; produce a report with key findings and gaps.",
  "input_params": {
    "audience": "VP Data at mid-market SaaS",
    "depth": "thorough",
    "must_cover": [
      "dimensions they actually score on",
      "where existing tools fail in their workflow"
    ]
  },
  "async": true
}
```

## `copilot`

General-purpose assistant. Gets the broadest tool surface (every registered tool except destructive and privileged ones: artifact deletion, archival, api keys, oauth clients, audit log). Does not commit to producing an artifact. The tool list is resolved at task-start time against the live registry, so new tools registered after boot are automatically available (except those explicitly excluded).

### Config

- **id**: `copilot`
- **version**: `1.0`
- **name**: `Copilot`
- **description**: General-purpose assistant. Broad tool surface minus destructive and privileged admin tools. May or may not produce an artifact depending on the task.
- **model**: `claude-sonnet-4-6`
- **temperature**: `0.4`
- **maxTurns**: `15`
- **producesArtifactType**: none (discretionary)

### Tool ids (resolved at runtime)

Every registered tool id, minus:

```
artifacts.delete
artifacts.archive
api_keys.*
oauth_clients.*
audit_log.*
```

### Input params

No fixed schema. Callers can pass any free-form parameters in `input_params`; the profile's initial-message template renders each key verbatim so the model can pick up on it.

### Use case examples

- Answer a question grounded in substrate without producing an artifact.
- Make a small edit to an existing artifact (`artifacts.update`) without starting a full writing run.
- Investigate a one-off substrate question and append a context entry.
- Mixed tasks where the agent should decide whether a saved deliverable is warranted.

### Sample `agents.start`

```json
{
  "profile_id": "copilot",
  "task": "Summarize our top three customer complaints from the last 30 days of interactions.",
  "input_params": {},
  "async": false
}
```

## `orchestrator`

Multi-step planner. Decomposes a complex user ask into a sequence of steps by reading a matching `agent_blueprint` recipe and carrying out its steps itself, calling the primitive tools (`data.*`, `context.*`, `knowledge_base.*`, `external_search.*`, `artifacts.*`) directly. Blueprints are read-and-walk recipes: there is no server-side runner and no hand-off tool. Use for multi-step workflows with cross-step dependencies. For a single quick delegation, prefer the copilot's direct `agents.start` pattern.

### Config

- **id**: `orchestrator`
- **version**: `1.0`
- **name**: `Orchestrator`
- **description**: Multi-step planner. Reads a matching `agent_blueprint` recipe and walks its steps itself with primitive tools. Does not spawn sub-agents directly.
- **model**: `claude-sonnet-4-6`
- **temperature**: `0.2` (deterministic planning)
- **maxTurns**: `50`
- **producesArtifactType**: none directly. The orchestrator walks a recipe and writes whatever artifacts the recipe's steps produce.

### Tool ids (resolved from scope bundle)

The orchestrator uses a positive scope bundle (`ORCHESTRATOR_GRANTED_SCOPES`) so new tools register automatically when the relevant scope is granted. Currently surfaces every tool in:

```
artifacts:read, context:read, context_entries:read, content:read,
data:read, team:read, observability:read, workflows:read,
config:read, knowledge_base:read,
artifacts:write
```

The `artifacts:write` scope gives the orchestrator `artifacts.create` / `artifacts.update` so it can persist the outputs of the recipe steps it walks. It deliberately does NOT hold `workflows:delegate`, so `agents.start` is structurally unreachable: the orchestrator does its own work rather than spawning sub-agents. It also has no `*:delete`, `keys:*`, `oauth_clients:*`, `audit_log:*`, `platform:*`, or `billing:*` scope.

### Input params

The orchestrator reads the `task` field plus any structured `input_params` you supply, and treats both as decomposition inputs. There are no required keys; common keys include:

| Field       | Type     | Notes                                                  |
| ----------- | -------- | ------------------------------------------------------ |
| `deadline`  | string   | ISO date the deliverable is due. Shapes step ordering. |
| `channels`  | string[] | Channels the resulting content should target.          |
| `audiences` | string[] | Personas the plan should consider.                     |
| Any custom  | any      | Forwarded into the orchestrator's initial message.     |

### Use case examples

- "Plan and draft next week's content with research + competitive context" -> read the matching recipe, run research, then draft the top pieces.
- "Investigate competitor X across web + internal interactions, then draft a battlecard" -> research first, then write the battlecard.
- "Refresh our weekly briefing across all topics" -> research per topic, then write the briefing.

### Sample `agents.start`

```json
{
  "profile_id": "orchestrator",
  "task": "Plan and draft next week's content, grounded in competitor activity and our most recent customer interactions.",
  "input_params": {
    "deadline": "2026-04-30",
    "channels": ["linkedin", "blog"]
  },
  "async": true
}
```

The orchestrator reads the matching `agent_blueprint` recipe, walks its steps with its own primitive tools, and replies with a summary of what it produced plus any artifact ids it wrote along the way. See [Agent blueprints](../blueprints/) for the recipe DSL and the starter set the orchestrator draws on.

## See also

- [Agents guide](../agents.md) for session lifecycle, SSE, and resume semantics
- [Agent blueprints](../blueprints/) for the recipe DSL the orchestrator reads and walks