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

# Weekly Metrics Pulse Reporter

> Schedule a DinoAI agent to check product metrics weekly, flag movements against a baseline, and post a digest to Slack for your review.

Instead of manually working through dashboards before every metrics review, let a scheduled DinoAI agent do the first pass: query the warehouse, compare this week against last, and post a short "what moved, what didn't" digest to Slack every Monday morning.

This guide starts deliberately small: one agent YAML and one Bolt schedule. Once the basic loop works, the [Extend the Agent](#extend-the-agent) section shows where to take it next.

<Info>
  **Before You Start**

  * A [DinoAI Background Agent Environment](/products/settings/connections/dinoai-background-agent-environment/index) connection so the agent can query your warehouse
  * [Slack integration](/integrations/slack) connected, with the Paradime bot invited to your metrics channel
  * Read the [Programmable Agents Quick Start](/products/dino-ai/programmable-agents/quick-start) first if you have never created an agent
</Info>

## What You'll Build

* One DinoAI agent (`weekly-metrics-reporter`) that queries your marts, compares the last complete week against the previous one, and posts a digest to Slack
* A Bolt schedule that runs it every Monday at 08:00

The digest is a single Slack message:

```
📈 WEEKLY METRICS PULSE :: week of <start date>

MOVED
  <metric>: <last week> → <this week> (<change>)

STABLE
  <metrics that were checked and did not move>

CAVEATS
  <anything that makes the numbers less trustworthy this week, or "none">
```

<Steps>
  <Step title="Create the Agent YAML">
    Commit this file at `.dinoai/agents/weekly-metrics-reporter.yml`. Replace the table names and metric list in the `goal` with your own; three to five metrics is plenty to start.

    ```yaml title=".dinoai/agents/weekly-metrics-reporter.yml" lineNumbers theme={"system"}
    name: weekly-metrics-reporter
    version: 1

    role: >
      Product analytics reporter for the weekly metrics review.

    goal: >
      On every run, for the last complete week (Monday to Sunday):

      1. Post a one-line kickoff message to Slack so the channel knows the
         run has started, for example
         "📈 Running the weekly metrics check for week of <date>, digest
         coming shortly."

      2. Query analytics.marts.fct_user_daily_activity to compute:
         - new registrations
         - weekly active users
         - % of new users who used the core feature
         - product page views
         - partner link clicks

      3. Compare each metric against the previous week.

      4. Post one digest message to Slack with three sections:
         MOVED (metrics that changed meaningfully, with both numbers),
         STABLE (metrics that were checked and did not move), and
         CAVEATS (anything that makes the numbers less trustworthy,
         for example a source table that is not fresh, or "none").

    backstory: >
      You are a concise product analyst. One line per metric, numbers always
      paired with last week's value. If a number looks implausible, say so
      in CAVEATS instead of reporting it as a real movement. Never go silent
      for the whole run: post a short one-line progress note to the Slack
      thread whenever a step takes more than a couple of minutes, for
      example "still computing weekly actives, 2 of 5 metrics done".

    tools:
      mode: allowlist
      list:
        - read_file
        - run_sql_query
        - post_slack_message

    slack:
      channel: "#product-metrics"
    ```

    <Info>
      Add your warehouse's metadata tools to the allowlist so the agent can look up table structure instead of guessing, for example `list_all_columns_in_snowflake_table` on Snowflake or `list_all_columns_in_bigquery_table` on BigQuery. See the [Tools Reference](/products/dino-ai/programmable-agents/tools-reference).
    </Info>
  </Step>

  <Step title="Run It Once">
    In the Bolt schedule editor, click **Add command**, pick **Run Paradime DinoAI Agent**, choose `weekly-metrics-reporter`, and set the task to:

    ```
    Run the weekly metrics check for the last complete week and post the digest to the product-metrics Slack channel.
    ```

    Save and hit **Run now**. The agent's messages stream into the Bolt run logs, and the digest lands in your Slack channel. Use the first couple of runs to tune the metric list and the wording in the `goal` until the digest reads the way you want.

    <Info>
      **Knowing the agent is alive.** A full run can take a few minutes, so the template makes the agent announce itself: a kickoff line when the run starts and a short progress note if a step runs long, both in the same Slack thread as the final digest. For a closer look while a run is in flight, the Bolt run logs stream every agent message live, and the background agent UI shows per-session traces of each tool call and lets you pause a run that has gone off on a tangent.
    </Info>
  </Step>

  <Step title="Schedule It Weekly">
    Set the schedule's trigger to a Monday morning cron. If you manage schedules as code:

    ```yaml title="Bolt schedules YAML" lineNumbers theme={"system"}
    schedules:
      - name: weekly metrics pulse
        slug: weekly-metrics-pulse
        environment: production
        git_branch: main
        commands:
          - paradime dinoai --agent=weekly-metrics-reporter --message="Run the weekly metrics check for the last complete week and post the digest to the product-metrics Slack channel."
        schedule: "0 8 * * 1"
        timezone: Europe/London
    ```

    Monday 08:00 gives the weekend's data time to land and puts the digest at the top of the channel when the week starts. That's it: the basic loop is done.
  </Step>
</Steps>

## Extend the Agent

Each of these is an independent upgrade. Add them one at a time, only when the basic digest starts feeling too shallow.

**Drill down in the Slack thread.** This one needs no setup at all. Mention the bot in the digest thread ("does that drop hold if you exclude the US?") and it resumes the same session with full context, runs the extra queries, and answers in the thread. See [Slack Agent](/products/dino-ai/slack-agent/index).

**Break metrics down by segment.** Add a line to the `goal` telling the agent to split any moved metric by market, device OS, or another user attribute, so the digest says "driven by Android" instead of just "moved".

**Move definitions into a spec file.** When the metric list outgrows the YAML, put it in a markdown file like `.dinoai/specs/weekly-metrics.md` (metrics, table locations, significance thresholds, minimum slice sizes) and change step 1 of the `goal` to "Read the spec file first". Analysts then evolve definitions with a normal PR, without touching the agent.

**Check pipeline health before reporting.** Add `list_bolt_schedules` and `get_bolt_run_logs` to the allowlist and tell the agent to verify the schedule that builds your marts succeeded for the reporting window. This is what separates "conversion dropped" from "the table didn't refresh".

**Attach business context.** If you keep a table of business events (campaigns, outages, releases), tell the agent to check it for events that overlap a movement and mention them in the digest.

**Add a monthly deep dive.** Create a second Bolt schedule that triggers the same agent with a different task message, for example "Compare the last complete month against the previous three months", timed a day before your monthly review.

#### Related Docs

* [**Programmable Agents Quick Start**: getting started with DinoAI agents](/products/dino-ai/programmable-agents/quick-start)
* [**YAML Configuration**: full reference for agent config options](/products/dino-ai/programmable-agents/yaml-configuration)
* [**Tools Reference**: all available tools, including per-warehouse metadata tools](/products/dino-ai/programmable-agents/tools-reference)
* [**Triggering from Bolt**: scheduling agents with cron and other triggers](/products/dino-ai/programmable-agents/triggering-from-bolt)
* [**Slack Agent**: mentioning the bot and resuming sessions in threads](/products/dino-ai/slack-agent/index)


## Related topics

- [Migration Playbook](/guides/migrations/dbt-cloud-tm-importer/migration-from-dbt-cloud-playbook.md)
- [Anomaly Tests Parameters](/integrations/elementary-data/anomaly-detection-tests/anomaly-tests-parameters.md)
- [Work Dashboard](/products/radar/team-efficiency-tracking/work-dashboard.md)
- [Snapshot Source Data Freshness](/products/bolt/creating-schedules/templates/dbt-tm-templates/snapshot-source-data-freshness.md)
- [Testing Source Freshness](/guides/dbt-fundamentals/configuring-your-dbt-project/testing-source-freshness.md)