One read of Claude Documentationclaude-docs-20260825T053705Z

claude-tag/admins/for-slack-admins Changed · +6 / -0 lines

## If you uninstall the app

claude-tag/admins/workspaces Changed · +12 / -3 lines

claude-tag/concepts/data-lifecycle New page · 104 lines, new page

# Data lifecycle and deletion ## What Anthropic stores ## How long data is kept ## What each action does to Claude-side data ### Actions in Slack ### Actions in Claude ## Direct messages ## Delete data or request deletion ## Audit records for deletions ## Related resources

A whole new page. There's nothing to diff it against, so here is what it says.

# Data lifecycle and deletion

> What Claude Tag stores on Anthropic's side, how long session transcripts and memory are kept, and what disconnecting a workspace, uninstalling the app, deleting a Slack channel, removing a scope, or leaving the organization does to that data.

export const BetaNote = () => <Info>Claude Tag is in public beta. Features and behavior described here may change before general availability.</Info>;

<BetaNote />

Claude Tag keeps a record of its work on Anthropic's side, separate from the messages in your Slack workspace. This page is for the Owner or security reviewer who needs to know what that record contains, how long Anthropic keeps it, and which actions in Slack or in your Claude admin settings delete it. For each action, the tables below say what is deleted and whether Claude keeps responding, because the two don't always go together.

## What Anthropic stores

There are two copies of the work Claude does in Slack. The messages, canvases, files, bookmarks, and pins in Slack stay in Slack under your workspace's own retention settings. Anthropic doesn't remove them when Claude-side data is deleted, and can't once the app is uninstalled, so delete those in Slack. On Anthropic's side, Claude Tag stores the following for each paired workspace.

| What                              | What it contains                                                                                                                                                                                                                                                                                                                                                                                        |
| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Session transcripts               | The record of one thread's, channel's, or direct message's work. A transcript holds the messages Claude was shown in the conversation and who sent them, files attached there, earlier versions of messages that were later edited, what Claude retrieved while working (Slack search results, messages it read in channels it's in, and data from connected tools), and everything Claude said and did |
| Memory                            | The notes Claude saves for each channel, the workspace-shared notes from public channels, and separate notes for each direct-message conversation. See [What Claude Tag remembers](/docs/claude-tag/users/memory)                                                                                                                                                                                            |
| Routines                          | The scheduled and run-once tasks set up in channels or in direct messages, with their instructions and run history                                                                                                                                                                                                                                                                                      |
| Scopes and their settings         | Each workspace and channel [scope](/docs/claude-tag/concepts/glossary#scope), with its custom instructions, version setting, and Access bundle bindings                                                                                                                                                                                                                                                      |
| Access bundles                    | The connections and credentials an Owner provisions. Bundles belong to your organization, not to a workspace                                                                                                                                                                                                                                                                                            |
| Account links                     | The link between each member's Slack account and their Claude account, and the tokens that link uses                                                                                                                                                                                                                                                                                                    |
| Published artifacts               | Pages a session published to claude.ai. See [Artifact visibility](/docs/claude-tag/concepts/security-and-data#artifact-visibility)                                                                                                                                                                                                                                                                           |
| The app's installation credential | The token the Claude app uses to read and post in your Slack workspace                                                                                                                                                                                                                                                                                                                                  |

Deleting or editing a message or file in Slack doesn't remove it from a transcript that already includes it. Messages from other people in the conversation, including guests, become part of the transcript the same way and are held as your organization's data.

## How long data is kept

During the beta there is no automatic retention period for Claude Tag data. Session transcripts, memory, routines, scopes, and account links are kept until one of the actions on this page deletes them. Your organization's custom data retention setting doesn't apply to Claude Tag transcripts or memory. It does apply to artifacts a session published, which follow the same retention rules as your organization's other shared artifacts.

Sessions Claude stops using are archived, not deleted. That includes a thread's session after someone sends [`@Claude !restart`](/docs/claude-tag/users/commands#restart-a-stuck-or-wrong-context-session), a session that closed because the thread's first message was deleted before anyone replied, and the channel-level sessions Claude replaces after about an hour of quiet or a day of age. An archived session keeps its full transcript until the channel's or workspace's data is deleted.

Letting a plan lapse, turning Claude Tag off, or no longer using it doesn't delete anything on its own. To delete a workspace's data when you stop using Claude Tag, [disconnect the workspace](/docs/claude-tag/admins/workspaces#revoke-a-pairing) or uninstall the app.

When an action below deletes data, deletion starts right away and completes in the background. Copies can remain in routine backups for a limited period after that before they age out.

## What each action does to Claude-side data

The first table covers actions taken in Slack, and the second covers actions taken in Claude. "Claude-side data" means the items listed under [What Anthropic stores](#what-anthropic-stores).

### Actions in Slack

| Action                                                                                                                          | Claude-side data                                                                                                                                                                                                                                                                                                                                                                                                                  | Does Claude keep responding?              |
| :------------------------------------------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------- |
| A Slack admin uninstalls the Claude app from a workspace                                                                        | Deleted, the same as [disconnecting the workspace](#actions-in-claude), plus the app's installation credential for that workspace. Access bundles, and routines members set up in direct messages, stay                                                                                                                                                                                                                           | No. The app is removed from the workspace |
| On Enterprise Grid, a Grid admin removes an org-wide installation of the app, from the whole grid or from one of its workspaces | Nothing is deleted. To delete the data, an Owner disconnects the grid, or a workspace that has its own pairing, in your Claude admin settings                                                                                                                                                                                                                                                                                     | No                                        |
| A channel is deleted in Slack                                                                                                   | Deleted: that channel's sessions and transcripts, including earlier sessions Claude had archived there, its channel memory, and its scope with the routines and artifacts that belong to it. Notes Claude saved to workspace memory from a public channel aren't tied to the channel and stay until you delete them or disconnect the workspace, as does anything created under the workspace scope rather than the channel's own | Not applicable                            |
| A channel is archived in Slack                                                                                                  | Nothing is deleted. Unarchiving the channel picks its memory, routines, and sessions back up                                                                                                                                                                                                                                                                                                                                      | Not while the channel is archived         |
| A public channel is made private                                                                                                | Nothing is deleted. Claude archives the channel's earlier sessions, and new sessions save to the channel's own memory store. Notes Claude saved to workspace memory while the channel was public stay there, readable from the workspace's other channels; see [Workspace memory](/docs/claude-tag/users/memory#workspace-memory)                                                                                                      | Yes                                       |
| Someone removes Claude from a channel with `/remove @Claude`                                                                    | Nothing is deleted. The channel's memory, routines, and past sessions stay on record, and re-adding Claude picks them back up. The channel's routines keep firing while Claude is out of the channel but can't post there                                                                                                                                                                                                         | No                                        |
| Someone edits a message Claude read                                                                                             | Claude receives the edit as a note, and the transcript keeps both the earlier and the edited text                                                                                                                                                                                                                                                                                                                                 | Yes                                       |
| Someone deletes a reply, or deletes a thread's first message after others have replied                                          | Nothing is removed from the transcript, and Claude isn't notified                                                                                                                                                                                                                                                                                                                                                                 | Yes                                       |
| Someone deletes a thread's first message before anyone has replied                                                              | The session closes and is archived with its transcript, including the deleted message                                                                                                                                                                                                                                                                                                                                             | No. The thread is gone                    |
| Someone deletes a file they attached in a thread Claude worked in                                                               | The copy Claude took into the session stays with the session and its transcript                                                                                                                                                                                                                                                                                                                                                   | Yes                                       |
| A member's Slack account is deactivated                                                                                         | Nothing is deleted. Their account link, direct-message conversations and notes, and their messages in channel transcripts stay. Channel routines they created keep running, and routines they set up in direct messages keep running until they're removed from your Claude organization                                                                                                                                          | Not to that member                        |

### Actions in Claude

| Action                                                                                                                                                                                                     | Claude-side data                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Does Claude keep responding?                                                                                                                                                                                 |
| :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| An Owner [disconnects a workspace](/docs/claude-tag/admins/workspaces#revoke-a-pairing)                                                                                                                         | Deleted: the workspace's sessions and transcripts, including members' direct-message conversations there; its channel, workspace, and direct-message memory; the routines set up in its channels and the artifacts published from them; its scopes with their instructions and bundle bindings; and members' account links. The Slack app and its installation credential stay so a workspace admin can pair again, and Access bundles, routines members set up in direct messages, and what Claude posted in Slack stay too. Pairing the same workspace to the same organization again within a few minutes can cancel the deletion | Stops in channels immediately. Direct messages keep working on each member's own Claude account until the deletion removes that member's account link                                                        |
| An Owner disconnects an Enterprise Grid                                                                                                                                                                    | The same as disconnecting a workspace, for every workspace in the grid that doesn't have its own workspace pairing, plus the app's installation credentials for those workspaces. Workspaces you paired individually stay connected and keep their data until you disconnect them                                                                                                                                                                                                                                                                                                                                                    | Stops in the affected workspaces                                                                                                                                                                             |
| An Owner removes a channel's scope with **Remove this scope** in the **Claude Tag's access** section                                                                                                       | Deleted: the channel's sessions and transcripts recorded up to that moment, including threads still in progress, its memory, its routines, and the artifacts published from it. The Slack channel itself is unchanged                                                                                                                                                                                                                                                                                                                                                                                                                | Yes. Claude stays in the channel and, when tagged again, starts fresh under the access it inherits from the workspace. To stop it as well, run `/remove @Claude` or set the scope's version to **Off** first |
| An Owner sets a scope's version to **Off**, turns off Claude in Slack for the organization, or turns off [direct messages](/docs/claude-tag/admins/restrict-access#allow-or-disable-direct-messages)            | Nothing is deleted. Turning the setting back on resumes with the existing memory, routines, and sessions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | No, in the affected scope                                                                                                                                                                                    |
| An Owner detaches a bundle from a scope, or deletes an Access bundle                                                                                                                                       | Detaching removes the binding, and deleting a bundle removes its credentials everywhere it was attached. Memory, routines, and transcripts are unaffected                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes, without that access                                                                                                                                                                                     |
| An Owner deletes entries from a scope's memory files, or someone in the channel tells Claude to forget an entry                                                                                            | The entry is removed from what Claude reads and from the memory files view. Earlier versions of the scope's memory remain stored with the scope until the scope's data is deleted                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes                                                                                                                                                                                                          |
| An Owner deletes a routine from the [**Scheduled work** tab](/docs/claude-tag/admins/audit#what-the-audit-view-lists), or someone asks Claude to delete it in the channel or direct message where it was set up | The routine and the sessions it ran are deleted. Pausing a routine there, or disabling it from the channel, keeps it on record                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Yes                                                                                                                                                                                                          |
| A member selects **Disconnect** in the Claude app's **Home** tab in Slack                                                                                                                                  | Removes the link between their Slack and Claude accounts and revokes the tokens Claude Tag held for them. Their earlier direct-message conversations and notes, and channel work they started, aren't deleted; those go with the workspace                                                                                                                                                                                                                                                                                                                                                                                           | In channels, yes. Direct messages and personal connectors stop working for that member until they reconnect                                                                                                  |
| A member is removed from your Claude organization                                                                                                                                                          | Nothing is deleted. They lose access within minutes, and routines they set up in direct messages are turned off. Their account link, direct-message conversations, and notes stay until the workspace is disconnected                                                                                                                                                                                                                                                                                                                                                                                                                | Not to that member                                                                                                                                                                                           |
| A member deletes their own Claude account                                                                                                                                                                  | On Team and Enterprise plans, deleting an individual account doesn't remove the Claude Tag data your organization holds about that member, including their direct-message conversations and notes and their account link. A member who wants the link and its tokens removed can select **Disconnect** in Slack before deleting their account                                                                                                                                                                                                                                                                                        | Not to that member                                                                                                                                                                                           |
| Your Claude organization is deleted                                                                                                                                                                        | All Claude Tag data for every paired workspace is deleted as part of the organization deletion. The Slack app isn't uninstalled by this, and its installation credential remains until the app is uninstalled, so uninstall it from each workspace in Slack as well                                                                                                                                                                                                                                                                                                                                                                  | No                                                                                                                                                                                                           |
| Your organization adopts Zero Data Retention or another restricted compliance configuration after pairing                                                                                                  | Nothing already stored is deleted. Disconnect each workspace to delete its data                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | No. Claude stops responding in Slack and new pairings are refused; see [Restricted compliance settings block Claude Tag](/docs/claude-tag/admins/troubleshooting#restricted-compliance-settings-block-claude-tag) |

## Direct messages

A direct-message conversation with Claude is stored the same way a channel thread is, as a session with a transcript, together with the notes Claude keeps for that conversation. Both are deleted with the workspace the member messaged Claude from, when that workspace is disconnected or the app is uninstalled from it, and when your Claude organization is deleted. They aren't deleted when the member selects **Disconnect** in Slack, when the member's Claude account is deleted on a Team or Enterprise plan, or when an Owner turns off direct messages.

Routines a member set up in a direct message belong to that member's Claude account. An Owner can delete them from the **Scheduled work** tab, or the member can ask Claude in the direct message to delete one. They are turned off when the member is removed from your Claude organization, and disconnecting the workspace doesn't delete them.

When a member first opens a direct message with Claude, the welcome Claude writes, which suggests channels based on the member's recent public-channel activity, runs as a short session that is stored like any other.

## Delete data or request deletion

The controls that delete Claude Tag data, from largest to smallest:

* **Disconnect a workspace or an Enterprise Grid** at [`claude.ai/admin-settings/claude-tag`](https://claude.ai/admin-settings/claude-tag), or uninstall the app from the workspace in Slack. Deletes all of that workspace's data. See [Revoke a pairing](/docs/claude-tag/admins/workspaces#revoke-a-pairing)
* **Remove a channel's scope** in the **Claude Tag's access** section. Deletes that channel's data recorded so far
* **Delete a scope's memory files**, from the scope's options menu, or tell Claude in the channel to forget an entry. See [Check and correct what Claude Tag remembers](/docs/claude-tag/users/memory#check-and-correct-what-claude-tag-remembers)
* **Delete a routine** from the **Scheduled work** tab, or ask Claude to delete it in the channel or direct message where it was set up. See [Audit Claude Tag activity](/docs/claude-tag/admins/audit)

There is no control in Slack or in your Claude admin settings that deletes a single thread's transcript on its own. During the beta, Claude Tag session transcripts and memory aren't included in your organization's data exports, and the Compliance API doesn't list or delete Claude Tag sessions. For a deletion request these controls don't cover, contact your account team or [[email protected]](mailto:[email protected]).

## Audit records for deletions

Disconnecting a workspace or an Enterprise Grid, and removing a channel's scope, are recorded in your organization's audit log, which you read through the [Compliance API](https://platform.claude.com/docs/en/api/compliance). Deletions that start in Slack, such as deleting a channel or uninstalling the app, aren't recorded there, and neither is a member's **Disconnect** in the **Home** tab.

## Related resources

* [Security and data handling](/docs/claude-tag/concepts/security-and-data): sandbox isolation, credential storage, and artifact visibility
* [Manage workspaces and versions](/docs/claude-tag/admins/workspaces#revoke-a-pairing): the Disconnect control and what it deletes
* [Restrict where Claude Tag operates](/docs/claude-tag/admins/restrict-access#quiet-or-remove-claude-tag): the ways to quiet or remove Claude, and which keep data
* [What Claude Tag remembers](/docs/claude-tag/users/memory): reading, correcting, and deleting memory
* [Audit Claude Tag activity](/docs/claude-tag/admins/audit): scheduled work, memory files, and network events

claude-tag/concepts/how-it-works Changed · +5 / -5 lines

claude-tag/users/getting-started Changed · +9 / -9 lines

claude-tag/users/memory Changed · +4 / -2 lines

office-agents/opentelemetry New page · 304 lines, new page

# Configure a custom OpenTelemetry collector ## What the collector receives ## Endpoint requirements ## Set up the collector ### Claude Enterprise organizations ### Direct-provider deployments ### Attribute size cap ## Deployment modes ## Span reference ### Resource attributes ### agent.query ### agent.stream ### agent.tool\_execution ### agent.compaction ### file.upload ## Span events ## Reconstruct a user session

A whole new page. There's nothing to diff it against, so here is what it says.

# Configure a custom OpenTelemetry collector

> Route the full Claude for M365 audit trail, including prompts, tool inputs and outputs, and document references, to an OpenTelemetry collector you operate.

Route complete audit telemetry from Claude for Excel, PowerPoint, Word,
and Outlook to your own OpenTelemetry (OTEL) collector. This gives you
control over retention and encryption and lets you feed the data into a
SIEM or observability platform.

This capability is available to Claude Enterprise organizations and to
direct-provider deployments on Amazon Bedrock, Google Cloud Vertex AI,
Azure AI Foundry, or an LLM gateway.

## What the collector receives

When a custom collector is configured, the add-in sends trace data for
every user turn. Each turn produces a tree of spans covering the prompt,
each model call, each tool execution, file uploads, and context
compaction.

All span attributes are included. They carry user-generated content:
prompt text, tool inputs and outputs, and document URLs. The allowlist
filter that strips sensitive attributes on the Anthropic path does not
run on this path. One normalization still applies: MCP connector tool
names are recorded as the literal `mcp_tool` rather than the
connector-specific name. Assistant response text is not included in
span data. Your organization owns the collected data; treat the
endpoint as containing prompt and document content when you scope
access controls and retention.

Metrics are not sent to custom collectors. The `office_agent.*` counter
namespace routes to Anthropic only. Every counter increment is also
recorded as a span event on the active span, so the same signals are
recoverable from the trace stream.

Telemetry is sent over OTLP/HTTP to `{your_url}/v1/traces`. gRPC is not
supported because of Office WebView constraints.

## Endpoint requirements

The add-in exports telemetry from each user's browser: the taskpane at
`https://pivot.claude.ai` posts directly to your collector, so every
export is a cross-origin request. The endpoint must:

* Answer the `OPTIONS` preflight with `Access-Control-Allow-Origin`
  covering `https://pivot.claude.ai` and `Access-Control-Allow-Headers`
  covering `Content-Type` plus any headers you configure, such as
  `Authorization`.
* Return the same `Access-Control-Allow-Origin` header on the `POST`
  response.

Managed OTLP ingest endpoints such as Grafana Cloud are built for
server-to-server export and generally do not answer browser CORS
preflights. Point the add-in at an OpenTelemetry Collector you run,
configure the `cors` block on its OTLP HTTP receiver, and have that
collector forward to your backend. The collector makes the authenticated
call to your backend, so no credential needs to appear in export headers
that reach every signed-in user's browser.

## Set up the collector

Configuration differs by how your users sign in.

### Claude Enterprise organizations

An organization administrator sets the collector endpoint in the
Claude admin console under Organization settings, Office agents. Two
settings are available:

| Setting         | Description                                                                       |
| --------------- | --------------------------------------------------------------------------------- |
| `otlp_endpoint` | Base URL of your OTLP collector. The add-in appends `/v1/traces`                  |
| `otlp_headers`  | Optional authentication headers in OpenTelemetry `key1=value1,key2=value2` format |

### Direct-provider deployments

Deployments that authenticate against Bedrock, Vertex AI, Foundry, or a
gateway supply the same two keys through the customer-configuration
channels described in
[Use Claude for M365 with third-party platforms](/docs/office-agents/third-party-platforms).

| Key             | Format                    | Description                                       |
| --------------- | ------------------------- | ------------------------------------------------- |
| `otlp_endpoint` | HTTPS URL                 | Collector base URL. Trailing slashes are stripped |
| `otlp_headers`  | `key1=value1,key2=value2` | Optional authentication headers                   |

The `claude-for-msft-365-install` setup plugin writes these for you. To
set them by hand, use any of the three channels below. Later channels override
earlier ones: manifest parameters are read first, then Entra claims,
then the bootstrap response.

**Manifest URL parameter.** Append the keys to the taskpane URL in your
custom manifest.

```text theme={null}
https://pivot.claude.ai/taskpane.html?otlp_endpoint=https://otel-collector.example.com&otlp_headers=Authorization=Bearer%20<token>
```

**Entra ID directory extension.** Register the keys as directory
extension attributes and assign them per user through Microsoft Graph.
The add-in reads them from the user's ID token via Nested App
Authentication. `extn.otlp_endpoint` maps to `otlp_endpoint` and
`extn.otlp_headers` maps to `otlp_headers`.

**Bootstrap endpoint response.** Include the keys in the JSON body your
bootstrap endpoint returns.

```json theme={null}
{
  "otlp_endpoint": "https://otel-collector.example.com",
  "otlp_headers": "Authorization=Bearer <token>"
}
```

### Attribute size cap

Prompt, tool-input, and tool-output attributes are truncated in the
add-in at 4,000 characters each by default and marked with a trailing
`…[truncated]`. Set the `otlp_attr_max_chars` configuration key to a
positive integer to change the cap. Values are clamped to between 256
and 32,000. Before raising the cap, confirm your collector and tracing
backend accept attribute values of the configured size: many backends
truncate or drop over-limit attributes at ingest, and a dropped span is
lost from the audit trail entirely.

## Deployment modes

The audit trail differs slightly depending on the sign-in path.

**Claude Enterprise (OAuth):** full audit trail including user identity
(`user.email`, `user.account_uuid`, `organization.id`), MCP server
metadata, and file-upload spans.

**Direct provider (Bedrock, Vertex AI, Foundry, gateway):** core audit
trail with prompts, tool inputs and outputs, and document URLs. No
Claude user identity, MCP metadata, or file-upload spans. Attribute
activity to a user by correlating `session.id` against your identity
provider or gateway logs.

## Span reference

Each user turn produces up to five span types. `agent.query` is the
root; `agent.stream` and `agent.compaction` are its children;
`agent.tool_execution` is a child of `agent.stream`; `file.upload`
arrives as a separate root span. The `agent.query` and
`agent.compaction` spans carry `agent.surface` (`sheet`, `doc`,
`slide`, or `mail`) and `agent.vendor` (`m` for Microsoft); the other
three do not. To filter those by surface, join `agent.stream` and
`agent.tool_execution` to their parent `agent.query` by trace ID, and
correlate `file.upload` to a turn by `session.id` and timestamp, since
it has its own trace ID and no surface attribute. Attributes marked
*content* carry user-generated data. Attributes marked *Claude sign-in
only* are populated only when users sign in with a Claude account.

### Resource attributes

These are set on every span.

| Attribute         | Description                                              |
| ----------------- | -------------------------------------------------------- |
| `service.name`    | Fixed value `office-agent`                               |
| `service.version` | Fixed value `1.0.0`. Use `git.sha` to identify the build |
| `git.sha`         | Build commit                                             |

### agent.query

Root span, one per user turn. SpanKind `INTERNAL`.

| Attribute                                       | Description                                                   |
| ----------------------------------------------- | ------------------------------------------------------------- |
| `agent.surface`                                 | `sheet`, `doc`, `slide`, or `mail`                            |
| `agent.vendor`                                  | `m`                                                           |
| `user.message` *content*                        | User prompt, truncated per the attribute cap                  |
| `user.message_chars`                            | Pre-truncation length of the prompt                           |
| `session.id`                                    | Opaque session identifier                                     |
| `document.url` *content*                        | URL of the open Office document                               |
| `agent.selected_model`                          | Model selected for the session                                |
| `office.platform`                               | `PC`, `Mac`, `OfficeOnline`, `iOS`, `Android`, or `Universal` |
| `office.version`                                | Office build number                                           |
| `user.email` *Claude sign-in only*              | User email                                                    |
| `user.account_uuid` *Claude sign-in only*       | Claude account UUID                                           |
| `organization.id` *Claude sign-in only*         | Claude organization UUID                                      |
| `org.rate_limit_tier` *Claude sign-in only*     | Subscription tier                                             |
| `mcp.configured_count` *Claude sign-in only*    | Configured MCP servers                                        |
| `mcp.connected_count` *Claude sign-in only*     | Connected MCP servers                                         |
| `mcp.failed_count` *Claude sign-in only*        | Failed MCP connections                                        |
| `file.upload.count` *Claude sign-in only*       | Files attached to the turn                                    |
| `file.upload.total_bytes` *Claude sign-in only* | Total uploaded bytes                                          |
| `error.name`                                    | Exception class name, on failure                              |
| `agent.query_phase`                             | Phase at failure, on failure                                  |

### agent.stream

One span per model API call, child of `agent.query`. SpanKind `CLIENT`.

| Attribute               | Description                                       |
| ----------------------- | ------------------------------------------------- |
| `model`                 | Model ID used                                     |
| `max_tokens`            | Maximum output tokens requested                   |
| `agent.message_count`   | Messages in the conversation at stream start      |
| `input_tokens`          | Input tokens billed                               |
| `output_tokens`         | Output tokens billed                              |
| `cache_read_tokens`     | Tokens served from prompt cache                   |
| `cache_creation_tokens` | Tokens written to prompt cache                    |
| `stop_reason`           | `end_turn`, `tool_use`, `max_tokens`, and similar |
| `request_id`            | Provider request ID for support correlation       |

The add-in requests prompt caching on every call. Cache token attributes
are set from the provider's response and omitted when the provider does
not return them.

### agent.tool\_execution

One span per tool call, child of `agent.stream`. SpanKind `INTERNAL`.
This is the primary record of what the model did to the document.

| Attribute               | Description                                                                                                           |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `tool_name`             | Tool identifier, for example `get_cell_ranges` or `execute_office_js`. MCP connector tools are recorded as `mcp_tool` |
| `tool.id`               | Unique invocation ID                                                                                                  |
| `tool.caller`           | `direct` for tools the add-in runs, or `server_tool` for tools the model provider runs                                |
| `tool.owner`            | `first_party` for built-in tools, or `third_party` for MCP connector tools                                            |
| `tool.read_write`       | `read` or `write`                                                                                                     |
| `tool.accept_decision`  | `manual` (user approved this action), `auto_accept` (standing approval), or `deferred` (queued for review)            |
| `tool.input` *content*  | Serialized tool input, truncated per the attribute cap                                                                |
| `tool.success`          | Boolean                                                                                                               |
| `tool.output` *content* | Serialized tool output, truncated per the attribute cap                                                               |
| `tool.output_chars`     | Full output length in characters                                                                                      |
| `tool.error_type`       | Error classification, on failure                                                                                      |
| `sheet.cells_read`      | Cells read, sheet surface only                                                                                        |
| `sheet.cells_written`   | Cells written, sheet surface only                                                                                     |
| `sheet.cells_copied`    | Cells copied, sheet surface only                                                                                      |

### agent.compaction

One span per automatic conversation summarization when context nears
the window limit, child of `agent.query`. SpanKind `CLIENT`. Also
carries `agent.surface`, `agent.vendor`, `session.id`,
`office.platform`, `office.version`, and `user.email` (Claude sign-in
only).

| Attribute                 | Description                      |
| ------------------------- | -------------------------------- |
| `compaction.pre_tokens`   | Token count before summarization |
| `compaction.post_tokens`  | Token count after summarization  |
| `compaction.tokens_saved` | Delta                            |
| `compaction.success`      | Boolean                          |
| `compaction.trigger`      | Currently always `reactive`      |

### file.upload

One span per uploaded file, emitted as its own root span rather than
under `agent.query`. SpanKind `CLIENT`. Claude sign-in only. Also
carries `session.id` and `user.email`. Correlate to the turn by
`session.id` and timestamp.

| Attribute                | Description                    |
| ------------------------ | ------------------------------ |
| `file.upload.size_bytes` | File size                      |
| `file.upload.mime_type`  | MIME type                      |
| `file.upload.file_id`    | Anthropic Files API identifier |
| `file.upload.success`    | Boolean                        |

## Span events

Spans carry timestamped events for lifecycle transitions:

* `agent.query`: `exception`, `file_upload`
* `agent.stream`: `first_token`, `stream_complete`, `stream_error`
* `agent.tool_execution`: `tool_init`, `tool_run`, `tool_result`, `tool_error`
* `agent.compaction`: `compaction_start`, `compaction_complete`, `compaction_error`
* `file.upload`: `exception`

Every internal product counter also records a span event with the same
name on the active span. For example, `office_agent.token.usage` is
emitted on each `agent.stream` span with `token_usage.type` (`input`,
`output`, `cacheRead`, or `cacheCreation`), `token_usage.model`, and
`token_usage.token_count`.

Surface-specific events include `office_agent.cell_edit_collision_total`
on Excel when a user is mid-edit while a tool writes, and the Word
document-edit funnel (`office_agent.doc_edit_received_total`,
`doc_edit_parsed_total`, `doc_edit_applied_total`,
`doc_proposed_edit_reviewed_total`). PowerPoint and Outlook add no
events beyond the common schema.

## Reconstruct a user session

The span tree produces a complete, ordered transcript in both deployment
modes.

For Claude Enterprise deployments, filter `agent.query` spans by
`user.email` or `user.account_uuid` and `session.id`, order them by
timestamp, and read `user.message` and `document.url` for each turn.
Then follow each `agent.query` span's trace ID to its
`agent.tool_execution` descendants, ordered by timestamp, to see what
was attempted (`tool.input`), the result (`tool.output`), and how it was
approved (`tool.accept_decision`).

For direct-provider deployments, filter `agent.query` spans by

Cut at 300 lines. The page has the rest.

office-agents/outlook Changed · +7 / -2 lines