See what moved in your Attio pipeline this week, and which deals went quiet

SKILL.md---
name: attio-weekly-pipeline-report
description: "Every Monday: Attio deals by stage, the ones that are new or changed stage last week, and the deals with no movement or contact for 14 days. Use when the user asks for this, or when it runs on a schedule."
---

# Attio weekly pipeline report

Every Monday: Attio deals by stage, the ones that are new or changed stage last week, and the deals with no movement or contact for 14 days.

Attio makes it easy to keep deals in a board, and just as easy to stop noticing the ones at the bottom of a column. A deal that has sat in Proposal for three weeks with no email or meeting looks exactly like one that moved yesterday.

The agent reads every deal and its stage history each Monday. It reports the board by stage, the deals that are new or changed stage in the last week, and the ones that have neither moved nor had an email or meeting for 14 days. Those are the deals to raise in the pipeline meeting.

## Two ways to get the data

Use the API or MCP route when you have an MCP server, a CLI or an API token for the app. Otherwise, if you can drive a browser the user is signed in to (Claude in Chrome, a Playwright or Chrome DevTools MCP server), use the browser route. Say which one you used.

## Route A: API or MCP server

### What you need

- An Attio user or access token with `record_permission:read` and `object_configuration:read`.
- Attio's MCP server (`https://mcp.attio.com/mcp`, OAuth; read tools run without confirmation) or an access token in `ATTIO_ACCESS_TOKEN` for the REST API.

If something is missing, say what and stop; do not invent numbers.

### Steps

1. **Read the stages** (Attio): `GET /v2/objects/deals/attributes/stage/statuses` for the stage titles in board order. Workspaces rename and add stages, so never assume the defaults.
2. **Read every deal** (Attio): `POST /v2/objects/deals/records/query` with `limit: 500` and `offset`, taking `name`, `stage` (its status title and `active_from`), `value`, `owner`, `associated_company` and `created_at`. Through Attio's MCP server, use `list-records` on deals.
3. **Find what moved**: New: `created_at` in the last 7 days. Moved: the current stage's `active_from` is in the last 7 days. To fetch only those, filter with `{"stage": {"active_from": {"$gte": "<date>"}}}`.
4. **Find deals gone quiet** (Attio): Open deals whose stage `active_from` is over 14 days old. For each, read the associated company's `last_email_interaction` and `last_calendar_interaction`; quiet means neither is in the last 14 days. These enriched attributes are not on every Attio plan, so fall back to stage age alone.
5. **Write the report**: Deals and value by stage, then new and moved deals with from and to stages, then quiet deals with days since anything happened and the owner.

## Route B: the browser

### What you need

- Signed in to Attio as a workspace member who can view the Deals object; saved views you create are visible to the team unless kept private.

If something is missing, say what and stop; do not invent numbers.

### Steps

Start at https://app.attio.com/. The user is signed in already; never type passwords or codes, and ask if a sign-in page appears.

1. **Open the Deals object**: The URL opens the workspace you used last; switch from the workspace menu at the top left if needed. Open **Deals** in the left sidebar and use a **Kanban** view grouped by **Stage**, with column sums on Value turned on, to read the deal count and value per stage.
2. **Find what is new or moved**: Switch to a **Table** view. Filter **Created at** is within the last 7 days for new deals. Then filter on **Stage** with its time condition (when the deal entered its current stage) set to the last 7 days for moved deals; the record's activity feed shows the stage it came from.
3. **Find deals gone quiet**: Filter open stages whose entered date is more than 14 days ago. Add the company's **Last email interaction** and **Last calendar interaction** columns through the associated company; a deal is quiet when neither is in the last 14 days. If your plan has no interaction attributes, use stage age alone and say so.
4. **Write the report**: Deals and value by stage, new deals, moved deals with from and to, then the quiet list with days since anything happened and the owner, and the one deal to raise first.

Note: Attio's filter wording changes between releases; the two conditions that matter are when a deal entered its stage and the company's last email and calendar interaction, which is enrichment data not on every plan. Save the three filtered views once so later runs only open them.

## The report

- **Pipeline by stage**: deal count and value.
- **New this week** and **moved stage**, with from and to.
- **Gone quiet**: no stage change and no email or meeting for 14 days, with the owner.
- One line on the deal to raise first.

## Post it to Briefkin

When `BRIEFKIN_TOKEN` is set, or `~/.config/briefkin/env` exists (the installer from https://briefkin.dev/docs writes it), also send the result to the user's Briefkin board as one card. Keep the `item_key` the same on every run so the card updates in place, use a new `event_id` per run, and put today's real numbers in place of the example ones. If the request fails, say so once and carry on.

```bash
[ -n "${BRIEFKIN_TOKEN:-}" ] || . ~/.config/briefkin/env
curl -sS -X POST "${BRIEFKIN_URL:-https://briefkin.dev}/v1/events" \
  -H "authorization: Bearer $BRIEFKIN_TOKEN" \
  -H "content-type: application/json" \
  -d @- <<'JSON'
{
  "v": 1,
  "event_id": "attio-weekly-pipeline-report/<date of this run, e.g. 2026-10-16>",
  "item_key": "attio-weekly-pipeline-report",
  "project": "Acme",
  "source": "Attio weekly pipeline report skill",
  "kind": "update",
  "title": "6 deals moved stage, 4 have gone quiet",
  "summary": "**31 open deals** worth $1.18M. 3 are new and 6 changed stage last week. **4 deals** worth $261,000 have not moved or had an email or meeting in 14 days.",
  "widget": [
    {
      "type": "Table",
      "props": {
        "columns": [
          "Deal",
          "Stage",
          "Value",
          "Note"
        ],
        "align": [
          "left",
          "left",
          "right",
          "left"
        ],
        "rows": [
          [
            "Kestrel Labs",
            "Negotiation",
            "$140,000",
            "Quiet 14 days"
          ],
          [
            "Northwind",
            "Proposal",
            "$84,000",
            "Quiet 21 days"
          ],
          [
            "Bluepeak",
            "Demo",
            "$22,000",
            "Quiet 17 days"
          ],
          [
            "Halcyon",
            "Qualified",
            "$15,000",
            "Quiet 15 days"
          ],
          [
            "Globex",
            "Negotiation",
            "$96,000",
            "Moved from Proposal"
          ],
          [
            "Initech",
            "Won",
            "$72,000",
            "Moved from Negotiation"
          ]
        ]
      }
    },
    {
      "type": "Badges",
      "props": {
        "items": [
          {
            "label": "Qualified 11"
          },
          {
            "label": "Demo 8"
          },
          {
            "label": "Proposal 7"
          },
          {
            "label": "Negotiation 5"
          },
          {
            "label": "4 quiet",
            "tone": "warn"
          }
        ]
      }
    }
  ]
}
JSON
```

Widgets come from the Briefkin catalog (https://briefkin.dev/v1/catalog). Without a token, just give the user the report.

## Run it on a schedule

Suggested: Mondays at 8:00 (`0 8 * * 1`). From cron, with the agent signed in on that machine:

```bash
0 8 * * 1 claude -p "Run the attio-weekly-pipeline-report skill"
# Codex: codex exec, Gemini CLI: gemini -p, Copilot CLI: copilot -p, OpenCode: opencode run
```

Or use the agent's own scheduler (Claude Code routines, Codex automations, Claude or ChatGPT scheduled tasks): https://briefkin.dev/skills/attio-weekly-pipeline-report#schedule

Source: https://briefkin.dev/skills/attio-weekly-pipeline-report