---
title: Agentic Tracking Plans
description: >-
  Use Bits AI to build a tracking plan from your product questions, instrument
  missing events, and generate a dashboard that answers those questions.
breadcrumbs: Docs > Product Analytics > Agentic Tracking Plans
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Agentic Tracking Plans

{% callout %}
# Important note for users on the following Datadog sites: app.ddog-gov.com, us2.ddog-gov.com

{% alert level="danger" %}
This product is not supported for your selected [Datadog site](https://docs.datadoghq.com/getting_started/site.md). ({% placeholder "user-datadog-site-name" /%}).
{% /alert %}

{% /callout %}

{% callout %}
##### Join the Preview!


Agentic Tracking Plans is in Preview. Complete the form to request access.




[Request Access](https://www.datadoghq.com/product-preview/agentic-tracking-plans/)
{% /callout %}

## Overview{% #overview %}

Agentic Tracking Plans helps you plan, instrument, and measure tracking for a feature. You provide a product brief and the questions you want to answer about the feature. Bits AI then:

1. Builds a tracking plan that lists the events and properties needed to answer each question and shows which ones already exist.
1. Helps you instrument the missing events through a Bits Code pull request, a Jira ticket, or a prompt for your own coding agent.
1. Creates a dashboard with charts that map to your questions.

Each event and property in the plan includes a description, so your team knows what it measures.

{% alert level="info" %}
For the most accurate tracking plan, connect the repository that contains your feature's code. Bits AI reads the code to learn how the feature is implemented, so its suggestions match the data your application can capture. Without the repository, Bits AI relies on your product brief and existing events, and may suggest events or properties that can't be effectively tracked in your code.
{% /alert %}

## Use cases{% #use-cases %}

Setting up tracking is often slow for both product managers and engineers. Product managers can't see what's already tracked, and engineers get requests without enough context. As a result, features ship without the data to evaluate them. Use Agentic Tracking Plans to:

- **Plan tracking before a launch (recommended)**: Set up tracking before a feature ships so you have complete data from the first day instead of finding gaps after launch.
- **Get started with Product Analytics**: If your team is setting up Product Analytics for the first time, get a purpose-built set of events and a dashboard that answers your key product questions from the first day.
- **Fill tracking gaps for an existing feature**: When existing data can't answer your questions, or the feature was never tracked, start from your questions. Bits AI identifies the events and properties that are missing.
- **Request tracking without waiting on a ticket**: Product managers can see which events already exist and define new ones without filing a ticket and waiting for engineering time.
- **Give engineers a clear, reviewable request**: Engineers get a specific pull request or ticket that explains which properties matter and why.
- **Reference events when you build charts**: A tracking plan documents the events and properties for a feature, so you can use it as a reference the next time you build a chart.

## Key concepts{% #key-concepts %}

| Term          | Definition                                                                                                                                                               |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Tracking plan | A list of the events and properties needed to measure a feature, along with the questions each one helps answer. A tracking plan belongs to one feature or product area. |
| Question      | Something you want to know about a feature, such as `What percentage of users who start checkout complete it?` Questions are the main input to a tracking plan.          |
| Event         | A user action or view that is recorded, such as a button click or a pageview.                                                                                            |
| Property      | Additional detail attached to an event, such as the plan type of the user or the payment method chosen. Properties let you filter and break down your analysis.          |

## Prerequisites{% #prerequisites %}

- Product Analytics enabled, with the RUM SDK instrumented in your application
- AI products enabled for your organization in [Plan & Usage > AI Credits](https://app.datadoghq.com/billing/ai-credits). Agentic Tracking Plans consumes [AI Credits](https://docs.datadoghq.com/account_management/billing/ai_credits.md).
- The **Bits Chat Access** permission
- (Recommended) A [source code integration](https://docs.datadoghq.com/bits_ai/bits_code/setup.md) for the repository that contains your feature's code and RUM instrumentation. Without it, Bits AI can't see how the feature is implemented, and may suggest events or properties that can't be effectively tracked in your code.
- (Optional) The **Bits Code Write** permission, required only to instrument with Bits Code

## Create a tracking plan{% #create-a-tracking-plan %}
Start a new tracking plan
1. In Datadog, go to [Product Analytics > Data > Tracking Plans](https://app.datadoghq.com/product-analytics/tracking-plans).
1. Click Create Tracking Plan and enter a name.
Provide context about your feature
1. Paste your product brief or product requirements document. If you do not have one, write a short description of the feature. Bits AI uses this context to understand what you are building and to suggest what to track. A one-line description produces generic suggestions, so include as much of the following as you can:

   - Product goals and success criteria
   - Product requirements
   - Key user flows or funnels for the feature
   - User stories
   - The URL of the page that contains the feature, if there is one

1. Next, select the application that contains the feature.

1. (Optional) Link the feature flag that controls the feature. The flag helps Bits AI find the relevant code faster and suggest more accurate tracking events. Click Add a flag, then select a [Datadog feature flag](https://docs.datadoghq.com/feature_flags.md) or a warehouse feature flag. If your flag is not listed, enter the flag name and select Manually Add Key.

1. (Recommended) Link the repository that contains your feature's code and RUM instrumentation. Bits AI reads the code to understand how the feature works, then suggests events and properties that match your implementation. Without the repository, Bits AI can still identify existing events, but it may suggest events or properties that can't be effectively tracked in your code, which means more review and rework before you instrument. Link the repository at this step so that Bits AI has the full context from the first suggestion. Linking it later doesn't improve the plan unless you ask Bits AI to regenerate it.

1. Click Continue.
Add your questions
Bits AI proposes a list of questions based on your context. Treat this list as a starting point.

1. Add, edit, or remove questions until the list covers everything you want to learn.

Good questions are specific and tied to a decision. For example:

   - `What percentage of users who open the invite dialog send an invite?`
   - `Which invite method do people use most often, email or link?`
   - `Which plan types complete setup most often?`

Generating the first list of questions can take a few minutes, because Bits AI reads your linked repository to understand the feature and check which data is already tracked. To find questions you may have missed, ask Bits AI in chat.

1. Click Continue to Tracking Plan.
Generate and review the tracking plan
Bits AI turns your questions into a tracking plan: the events and properties required to answer them. The table shows which items already exist and which still need to be added. Each item links back to the questions it supports.

Review the plan before you instrument anything:

- Check that each event and property is needed to answer a question. Remove any you do not need.
- Check that no proposed property collects personal data or other data you should not collect.
- If you did not link a repository, confirm that each proposed event and property matches how the feature is implemented. If you link a repository later and ask Bits AI to regenerate the plan after you instrument, the new plan may not be compatible with the instrumentation you already added.
- Edit names, descriptions, and properties directly in the table, or ask Bits AI in chat to make changes. You can keep using chat after the plan is generated to ask questions and fix problems.
Save, instrument, and verify
1. Click Save to store your latest edits.

1. Choose how to add the missing events and properties:

| Option                          | What happens                                                                                                                          | Best when                                                                                           |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Instrument with Bits Code       | Bits Code writes the instrumentation in your repository and opens a pull request for your team to review. It does not merge anything. | You have Bits Code enabled and your team is comfortable reviewing AI-authored pull requests.        |
| Share with engineering          | Share the link to the tracking plan, or create a Jira ticket that carries all of the context, so an engineer can pick it up.          | You want engineers to own the implementation, or you do not have Bits Code.                         |
| Copy the instrumentation prompt | Copy a ready-made prompt into your own coding agent or IDE assistant.                                                                 | Your team already uses a coding agent, or you cannot grant Datadog write access to your repository. |

**Note**: If your team has policies about AI-authored code changes, agree with your engineers on how Bits Code pull requests are reviewed before you choose Instrument with Bits Code.

1. After the instrumentation code is ready, your engineers review it, request changes if needed, and merge and deploy it.

1. After the code is live and users trigger the events, Product Analytics detects them. Check the latest status in the tracking plan to verify that Product Analytics receives the events.
Create a dashboard
Generate a dashboard that tracks the answers to the questions in your plan:

1. On the tracking plan page, click New Dashboard. Bits AI creates a dashboard with charts that answer the questions in your plan. You can create the dashboard any time after you save the plan, but charts for events that are not yet instrumented in your code remain empty until the instrumentation is deployed.
1. Review the generated dashboard, and edit or remove any charts that do not match what you wanted to measure.

## Billing{% #billing %}

Agentic Tracking Plans uses Bits AI. Generating questions and tracking plans consumes AI Credits through Bits Chat. Instrumenting your code with Bits Code consumes AI Credits through Bits Code. For pricing details, see [AI Credits](https://docs.datadoghq.com/account_management/billing/ai_credits.md).

## Further reading{% #further-reading %}

Additional helpful documentation, links, and articles:

- [Learn about Product Analytics](https://docs.datadoghq.com/product_analytics.md)
- [Learn about Bits Code](https://docs.datadoghq.com/bits_ai/bits_code.md)
- [Learn about AI Credits](https://docs.datadoghq.com/account_management/billing/ai_credits.md)
