Skip to main content
skill CX Codex

dd-audit-ai-activity — Claude Code skill: audit AI actions in Datadog

Reads the Datadog Audit Trail and shows which users called Datadog MCP tools, what those calls touched, and which events look off.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add datadog-labs/agent-skills --skill dd-audit-ai-activity -a claude-code
npx skills add datadog-labs/agent-skills --skill ai-activity-audit -a claude-code
Open on GitHub

What dd-audit-ai-activity does

This skill answers a plain question: what has the AI assistant been doing inside your Datadog org? Every Datadog MCP tool call lands in Audit Trail under the Bits AI SRE category, and the skill pulls those records out — user email, actor type, action, resource type and id, client IP and country.

What you get is a set of pup audit-logs search queries piped through jq. One lists all MCP activity in a time window. Another groups calls by user so you can see who leans on the assistant most. A third filters for created, modified or deleted resources, and a fourth narrows everything down to a single user. The weekly summary rolls it into totals, unique users, a top-five list, and breakdowns by action and resource type. A separate table flags the events worth a look: deletions of monitors or dashboards, activity from SUPPORT_USER, a first-time user, a burst of calls in a short window, or access outside a user's usual scope.

You need Audit Trail access first. The author recommends pup auth login for OAuth2, or DD_API_KEY plus DD_APP_KEY with the audit_logs_read scope. Skip that and the queries come back empty, which reads like the assistant did nothing at all. The skill only inspects events that were already logged; it does not block or revoke anything.

What it helps with

  • list every Datadog MCP tool call from the past week
  • rank users by how often they invoke the AI assistant
  • pull the resources AI calls created, changed or deleted
  • trace one employee's assistant activity over 30 days
  • build a weekly AI governance report with totals and top users

Example prompts for the agent

  • Show all Datadog MCP tool calls from the last 7 days with user email and action
  • Build a weekly AI activity report: total tool calls, unique users, top 5
  • Which dashboards and monitors did the AI delete or modify in the last 7 days?

How to install dd-audit-ai-activity

1Skills CLI (Vercel)

npx skills add datadog-labs/agent-skills --skill dd-audit-ai-activity -a claude-code
npx skills add datadog-labs/agent-skills --skill ai-activity-audit -a claude-code

2Manually: put the files in place

~/.claude/skills/ai-activity-audit/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ai-activity-audit/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about dd-audit-ai-activity

How do I install dd-audit-ai-activity in Claude?

Run npx skills add datadog-labs/agent-skills --skill dd-audit-ai-activity -a claude-code, then npx skills add datadog-labs/agent-skills --skill ai-activity-audit -a claude-code. The skill file ends up at ~/.claude/skills/ai-activity-audit/SKILL.md.

What does dd-audit-ai-activity do?

It queries Datadog Audit Trail for Datadog MCP tool calls and reports which users made them and which resources were affected. It also flags events that warrant a closer look during a security review.

What do I need before running it?

Audit Trail access: either pup auth login for OAuth2, or DD_API_KEY and DD_APP_KEY with the audit_logs_read scope. Without one of those the log queries return nothing.

Source text

SKILL.md · MIT
---
name: dd-audit-ai-activity
description: Audit what the Bits AI assistant (MCP server) has done in your Datadog org — tool calls by user, resources accessed, and anomaly flags for AI governance.
metadata:
  version: "0.1.0"
  author: datadog-labs
  repository: https://github.com/datadog-labs/agent-skills
  tags: datadog,audit,ai,mcp,bits-ai,governance,dd-audit
  alwaysApply: "false"
---

# Audit Trail: AI Activity Audit

Every Datadog MCP tool call is recorded in Audit Trail under the `Bits AI SRE` category. This skill surfaces what the AI assistant has done in your org — which users invoked it, which tools were called, and which resources were affected.

## Prerequisites

```bash
pup auth login   # OAuth2 (recommended)
# or set DD_API_KEY + DD_APP_KEY with audit_logs_read scope
```

## Queries

### All MCP tool activity in a time window

```bash
pup audit-logs search --query "@evt.name:\"MCP Server\"" --from 7d --limit 500 -o json \
  | jq '[.data[] | {
      timestamp: .attributes.timestamp,
      user: .attributes.attributes.usr.email,
      actor_type: .attributes.attributes.evt.actor.type,
      action: .attributes.attributes.action,
      resource_type: .attributes.attributes.asset.type,
      resource_id: .attributes.attributes.asset.id,
      ip: .attributes.attributes.network.client.ip,
      country: .attributes.attributes.network.client.geoip.country.name
    }]'
```

### Activity by user (who is using the AI assistant most?)

```bash
pup audit-logs search --query "@evt.name:\"MCP Server\"" --from 30d --limit 1000 -o json \
  | jq '[.data[] | .attributes.attributes.usr.email]
    | group_by(.)
    | map({user: .[0], tool_calls: length})
    | sort_by(-.tool_calls)'
```

### Resources modified by AI tool calls

```bash
pup audit-logs search \
  --query "@evt.name:\"MCP Server\" @action:(created OR modified OR deleted)" \
  --from 7d --limit 500 -o json \
  | jq '[.data[] | {
      timestamp: .attributes.timestamp,
      user: .attributes.attributes.usr.email,
      action: .attributes.attributes.action,
      resource_type: .attributes.attributes.asset.type,
      resource_id: .attributes.attributes.asset.id
    }]'
```

### AI activity for a specific user

```bash
pup audit-logs search \
  --query "@evt.name:\"MCP Server\" @usr.email:[email protected]" \
  --from 30d --limit 500 -o json \
  | jq '[.data[] | {
      timestamp: .attributes.timestamp,
      action: .attributes.attributes.action,
      resource_type: .attributes.attributes.asset.type,
      resource_id: .attributes.attributes.asset.id
    }]'
```

### Weekly summary report

```bash
pup audit-logs search --query "@evt.name:\"MCP Server\"" --from 7d --limit 1000 -o json \
  | jq '{
      total_tool_calls: (.data | length),
      unique_users: ([.data[] | .attributes.attributes.usr.email] | unique | length),
      top_users: (
        [.data[] | .attributes.attributes.usr.email]
        | group_by(.)
        | map({user: .[0], calls: length})
        | sort_by(-.calls)
        | .[:5]
      ),
      actions_breakdown: (
        [.data[] | .attributes.attributes.action]
        | group_by(.)
        | map({action: .[0], count: length})
        | sort_by(-.count)
      ),
      resource_types: (
        [.data[] | .attributes.attributes.asset.type]
        | group_by(.)
        | map({type: .[0], count: length})
        | sort_by(-.count)
      )
    }'
```

## Anomaly Flags

| Signal | Governance concern |
|--------|--------------------|
| AI performing `deleted` actions on monitors or dashboards | Review whether destructive AI operations are expected |
| AI acting as `SUPPORT_USER` | Datadog support using AI on behalf of org |
| First-time user invoking AI tools | New user accessing AI assistant |
| High volume of tool calls in short window | Automated/batch AI usage |
| AI accessing resources outside user's normal scope | Potential over-permissioned AI session |

## Output Format

```
AI Activity Audit — [Org] — [Date Range]

Total MCP tool calls: [N]
Unique users: [N]

Top users:
  [[email protected]]: [N] calls

Actions breakdown:
  accessed: [N]
  modified: [N]
  created: [N]
  deleted: [N]

Resource types affected:
  dashboard: [N]
  monitor: [N]

Anomalies:
  [List any flagged events with timestamp, user, action, resource]
```

## Context

This skill is most useful for:
- **Security reviews:** Verifying AI actions were authorized and within expected scope
- **Compliance audits:** Demonstrating AI activity is logged and attributable to specific users
- **Governance reports:** Understanding adoption and risk surface of the AI assistant across the org

No other observability vendor audits their AI assistant's actions at this level of detail.

## References

- [Bits AI SRE documentation](https://docs.datadoghq.com/bits_ai/)
- [Audit Trail events — Bits AI SRE category](https://docs.datadoghq.com/account_management/audit_trail/events/)
- [MCP Server setup](https://docs.datadoghq.com/bits_ai/mcp_server/)

© datadog-labs · MIT · datadog-labs/agent-skills

Similar skills

Everything for Security →

From the same set20

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor