Zime

View saved version →

---
name: account-research
description: "Research a new prospect company before you reach out. Checks if they fit our ICP and who the buyers might be. Use for companies not yet in CRM. For existing accounts, use review-account instead."
license: MIT
metadata:
  zime:skill-id: a996cb94-8af5-4b6d-ae1e-5bd2fe043782
  zime:tag: research
  zime:roles: ae,bdr
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Account Research

Before anything else, call the Zime connector tool `skill_used` with skill_id `a996cb94-8af5-4b6d-ae1e-5bd2fe043782`, skill_version `1` and skill_slug `account-research`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Researches a company **before** there's a relationship. The entity isn't in
CRM, there are no calls to read, and no Zime signals exist for it — so this
skill is web research with one grounding call, not a workspace lookup.

## What makes this different from every other skill here

Every other skill in this plugin resolves an entity in Zime and delegates to
an agent. This one inverts that:

- **No resolve step.** The prospect isn't in our CRM. If they were, the user
  wants `review-account`.
- **Web search is the primary source**, not a fallback.
- **`ask_zime` is called once, and not about the prospect.** It's called about
  *us* — to pull our ICP definition and what our won customers look like, so
  "do they fit" is measured against something real instead of a guess.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                     ACCOUNT RESEARCH                             │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — GROUND THE BASELINE (once, about US)                   │
│  ✓ ask_zime: our ICP, our won-customer patterns                  │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — RESEARCH THE PROSPECT (web search, primary)            │
│  ✓ What they do, size, funding, customers                        │
│  ✓ Their GTM / CS motion — how they sell and support             │
│  ✓ Buyers and likely champions                                   │
│  ✓ Trigger events: funding, hiring, launches, reorgs             │
├─────────────────────────────────────────────────────────────────┤
│  STEP 3 — SCORE THE FIT (against Step 1's baseline)              │
│  ✓ ICP scorecard with evidence per dimension                     │
│  ✓ Recommended angle and entry point                             │
├─────────────────────────────────────────────────────────────────┤
│  NEVER                                                           │
│  ✗ Invented headcount, revenue, or funding figures               │
│  ✗ A named "champion" with no source                             │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@account-research <company name or domain>
```

In the ChatGPT desktop app you can also type `/account-research`.

Research the prospect the user named.

## Routing

- An **existing CRM account**, or a deal already in flight — record, owner,
  stage, risk → `review-account`. This skill is for companies not yet in CRM.
- A competitor rather than a prospect → `competitive-intelligence` (which
  reads our calls, not the web).
- Building the outreach asset after research → `create-sales-asset`.

## What I Need From You

The company name, ideally with a domain. Helpful additions:

- **Who you'd be selling to** (CS leader, VP Sales, RevOps) — focuses the
  buyer research
- **Why they're on your list** — inbound, a trigger event, a referral

If the company turns out to already be in CRM, say so and offer
`review-account` rather than researching them as new.

## MCP mode (when zime-mcp is connected)

**Required tool:** `ask_zime`, used once for the baseline.

### Step 1 — pull our own ICP baseline

```json
{ "question": "What is our ICP

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: actions-commitments
description: "Shows open action items and commitments. Who promised what, and by when. Works for one call, one deal, or a whole account."
license: MIT
metadata:
  zime:skill-id: 65cb2c4b-4d72-4393-81b5-7546750abae2
  zime:tag: execution
  zime:roles: ae,cs
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Actions & Commitments

Before anything else, call the Zime connector tool `skill_used` with skill_id `65cb2c4b-4d72-4393-81b5-7546750abae2`, skill_version `1` and skill_slug `actions-commitments`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Answers "what's still open?" with commitments that were actually made — who
owns each one and when it's due. The value here is that nothing is invented:
an unclaimed action with no owner is reported as unowned, not assigned to
whoever seems likely.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                    ACTIONS & COMMITMENTS                         │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE SCOPE (this skill)                             │
│  ✓ One call    → list_meetings  → call_id                        │
│  ✓ One deal    → list_deals     → deal_id                        │
│  ✓ An account  → list_deals / list_meetings for that account     │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — DELEGATE (Zime agent)                                  │
│  + ask_zime, naming the call, deal, or account in the question    │
│  + Agent extracts commitments, owners, dates from real calls     │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Extract from a transcript file the user provides              │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@actions-commitments <call, deal, or account> [+ when]
```

In the ChatGPT desktop app you can also type `/actions-commitments`.

Show the open commitments for the call, deal or account the user named.

## Routing

- A full recap of one call, not just its actions → `review-call`.
- The email that chases these items → `follow-up`.
- Deal risk and strategy, or pipeline-wide status across many deals, rather
  than open items → `review-account`.

## What I Need From You

The scope — a call, a deal, or an account — and a time window if you want it
bounded ("this week", "since the QBR"). If the scope is ambiguous I'll ask
rather than guessing between a call and a deal.

## MCP mode (required when zime-mcp is connected)

**Required tools:** `list_meetings` and/or `list_deals` (resolve), plus
`ask_zime` (extract).

> `ask_zime` routes to Zime's global agent, with no separate id
> argument — name the call, deal, or account in the question text. Extracting
> commitments yourself from a fetched transcript while it's available is a
> failure of this skill: the agent also sees extracted signals and CRM
> linkage, and it distinguishes a firm commitment from an idea someone
> floated.

### Step 1 — resolve the scope

Pick the narrowest scope the request implies:

| Request shape | Resolve with | Then |
|---|---|---|
| "on the Acme call" | `list_meetings` (`recorded: true`) | name the call in the question |
| "on the Northwind deal" | `list_deals` | name the deal in the question |
| "what did I promise Globex" | `list_deals` for that account | name the account in the question |

`multiple_matches` → show candidates, ask, pin the id. Never guess.
`no_match` → say the window or naming likely excludes it; offer to widen.

### Step 2 — delegate the extraction

```json
{ "question": "List every commitment and action item from the Acme call on Aug 12: what was promised, who owns it, and the due date if one was stated. Separate our commitments from the customer's." }

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: call-prep
description: "Builds a quick prep note before an upcoming call. Shows the biggest risk, and 2-3 things to do. Only works for your own upcoming meetings."
license: MIT
metadata:
  zime:skill-id: dfeec687-3057-43fb-abc0-bb0c46256665
  zime:tag: workflow
  zime:roles: ae,se
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Call Prep

Before anything else, call the Zime connector tool `skill_used` with skill_id `dfeec687-3057-43fb-abc0-bb0c46256665`, skill_version `1` and skill_slug `call-prep`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Gets a rep up to speed before a customer call. The prep-note agent builds the
note from the meeting's CRM deal and account, its external attendees, and the
relevant past calls — context no chat history can match. This skill's job is
to resolve the right meeting and deliver what the agent returns.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                          CALL PREP                               │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE (this skill)                                   │
│  ✓ list_meetings, forward-looking window                         │
│  ✓ Ambiguous → show candidates, ask, pin meeting_id              │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — DELEGATE (Zime prep-note agent)                        │
│  + prep_note builds the note from deal, account, attendees,      │
│    and past calls — grounded in real workspace data              │
│  + Returns the finished note; this skill does not rewrite it     │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Assemble from a meeting-context file + past transcripts       │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@call-prep <company or meeting> [+ when]
```

In the ChatGPT desktop app you can also type `/call-prep`.

Prep for the call the user named.

## Routing

- Anything about PAST calls (recaps, "what objections came up") →
  `review-call`.
- Deal strategy not tied to one upcoming call ("how do I win this") →
  `review-account`.
- "What meetings do I have?" is a schedule listing → `daily-briefing`.
- Use this skill only when there is an upcoming, scheduled call AND the user
  wants to prepare for it.

## What I Need From You

The company or person, and a time hint if you have one ("tomorrow", "my
3pm"). If several upcoming meetings match, I'll show them and ask.

This only preps **your own** meetings — ones you organize or attend. If you
ask to prep someone else's call, I'll say so rather than guessing.

## MCP mode (required when zime-mcp is connected)

**Required tools:** `list_meetings` (resolve) and `prep_note` (generate).

Hand-building the note while `prep_note` is available is a failure of this
skill, even when the user gave you enough context to write something
plausible — the agent grounds every claim in the workspace's real calls and
CRM.

### Step 1 — resolve the meeting

Call `list_meetings` with a **forward-looking** window (an upcoming meeting
is by definition in the future; a past-only window will find nothing).

```json
{ "query": "Meridian", "start_date": "2026-08-13", "end_date": "2026-08-27" }
```

- `resolved` → take its `meeting_id` and go to Step 2.
- `multiple_matches` → show the candidates with their times, ask which one,
  then use the chosen `meeting_id`. Never pick for the user.
- `no_match` → say there's no matching upcoming meeting in that window and
  offer to widen it. Don't fall through to prepping a past call.

### Step 2 — delegate to the prep-note agent

Call `prep_note` with the resolved id.

```json
{ "query": "prep me for my Meridian call tomorrow", "calendar_event_id": "<meeting_i

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: competitive-intelligence
description: "Shows what customers actually say about competitors. Where they come up, what they claim, and how we compare. Only uses real quotes from real calls."
license: MIT
metadata:
  zime:skill-id: 97b63479-93dc-4cf2-9ee1-754a216267b4
  zime:tag: intelligence
  zime:roles: ae,se
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Competitive Intelligence

Before anything else, call the Zime connector tool `skill_used` with skill_id `97b63479-93dc-4cf2-9ee1-754a216267b4`, skill_version `1` and skill_slug `competitive-intelligence`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Answers "what are customers actually saying about Competitor X?" from the
workspace's own calls. The value is that it's evidence from real
conversations, not what the internet says about a competitor — and the two are
often very different.

## The line this skill holds

General market knowledge about a competitor is the failure mode. What their
website claims, their published pricing, their reputation — none of that is
what this skill returns. If the corpus has nothing on a competitor, the answer
is "nothing in our calls mentions them", not a summary from training data.
That distinction is the whole point: a rep can act on "three customers raised
their SSO gap last quarter" and cannot act on "they're generally seen as
cheaper."

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                  COMPETITIVE INTELLIGENCE                        │
├─────────────────────────────────────────────────────────────────┤
│  SCOPE FIRST (this skill decides which)                          │
│  ✓ "on the Acme call"    → list_meetings, then name the call in the │
│                             ask_zime question                │
│  ✓ "across our deals"    → ask_zime directly (no resolve needed)  │
├─────────────────────────────────────────────────────────────────┤
│  DELEGATE (Zime agent)                                           │
│  + Agent reads real calls, mentions, and extracted signals       │
│  + Returns evidence with accounts and dates attached             │
├─────────────────────────────────────────────────────────────────┤
│  NEVER                                                           │
│  ✗ Competitor facts from general knowledge                       │
│  ✗ A "typical" objection nobody actually raised                  │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Scan a transcript file the user provides                      │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@competitive-intelligence <competitor> [+ scope] [+ when]
```

In the ChatGPT desktop app you can also type `/competitive-intelligence`.

Report competitive intel on the competitor the user named.

## Routing

- Objections on ONE deal, competitor or not, or win/loss rates and pipeline
  totals → `review-account`.
- A recap of one call that happened to mention a competitor → `review-call`.
- Turning competitive evidence into a battlecard or talking points →
  `create-sales-asset`.

## What I Need From You

The competitor name. Scope and window help: "on the Acme call" is a different
question from "across our deals this quarter", and this skill routes them
differently.

## MCP mode (required when zime-mcp is connected)

**Required tools:** `ask_zime` (all scopes). For single-call scope also
`list_meetings` first, to name the exact call in the question.

> `ask_zime` routes to Zime's global agent across the whole accessible
> corpus, with no separate scoping argument — narrow it by naming the call,
> account, or window inside the question text. Answering from general
> knowledge about the competitor while it's available is a failure of this
> skill.

### Cho

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: create-sales-asset
description: "Builds a sales asset from real customer evidence only, never made up facts. Covers account review decks (as a slide-by-slide outline), one-pagers, battlecards, case studies, and objection talking points. Always an internal draft, not customer-ready."
license: MIT
metadata:
  zime:skill-id: 33b3e084-8df2-40bd-b91f-1d5199dd9a14
  zime:tag: communication
  zime:roles: ae,marketing
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Sales Asset Builder

Before anything else, call the Zime connector tool `skill_used` with skill_id `33b3e084-8df2-40bd-b91f-1d5199dd9a14`, skill_version `1` and skill_slug `create-sales-asset`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Turns "build me an account review for Acme" into a draft in our house format.
This skill owns the **structure and framing**; the agents own the **facts**. It
never originates a metric, a quote, or a "customer said" line.

## The hard rule

Every factual claim in the asset — a metric, a quoted line, a stated customer
outcome, a competitive win — must trace to something a tool returned in **this
conversation**, with the account and date attached. If a needed fact wasn't
returned, the asset marks the gap open rather than filling it with a plausible
number or a paraphrased "customers typically say" line.

This is the one rule the skill cannot bend. Arranging real tool output is the
job; inventing supporting evidence is a failure of it — even when the invented
line looks exactly like something a customer would say. An asset is the
deliverable most likely to be pasted into a customer-facing deck, which is
precisely why fabrication here is the most expensive.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                   SALES ASSET BUILDER                            │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE THE SUBJECT                                    │
│  ✓ list_accounts (account asset) or list_deals (deal asset)      │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — GATHER DATED EVIDENCE                                  │
│  + ask_zime — signals, risks, expansion, outcomes, patterns │
│  + get_transcript — the exact line, when a real quote is needed  │
├─────────────────────────────────────────────────────────────────┤
│  STEP 3 — ASSEMBLE (house format)                                │
│  ✓ references/deck-grammar.md — the section order we use         │
│  ✓ Every row carries evidence + date + account                   │
├─────────────────────────────────────────────────────────────────┤
│  STEP 4 — DELIVER                                                │
│  ✓ Account review deck → slide-by-slide outline in markdown      │
│  ✓ Every other asset type → markdown, ready to paste             │
├─────────────────────────────────────────────────────────────────┤
│  ALWAYS                                                          │
│  ! Internal draft. Needs review before it leaves the building.   │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@create-sales-asset <asset type> for <account, deal, or competitor>
```

In the ChatGPT desktop app you can also type `/create-sales-asset`.

Build the asset the user asked for.

## Routing

- A pipeline stat, risk or strategy on one deal, or one CRM fact, with no
  asset to build → `review-account`.
- A recap of one call, or the email after it → `review-call` / `follow-up`.
- Competitive evidence gathering with no asset yet →
  `competitive-intelligence` (then come back here to shape it).
- Researching a **prospect** we haven't sold to → `account-research`.

## What I Need From You

**Which asset**, and **what it's about**:

| Asset | Subject | Typically needs |
|---|---|---|
| Account review deck | one accoun

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: create-sales-to-cs-handover
description: "Builds the Sales to CS handover doc for one deal or account. Covers stakeholders, why we won, open objections, commitments, and call history. Gives you the handover as markdown, ready to paste into a doc."
license: MIT
metadata:
  zime:skill-id: 0e82dc75-cffd-449c-b45f-ba8b00f94ea1
  zime:tag: workflow
  zime:roles: ae,cs
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Sales → CS Handover

Before anything else, call the Zime connector tool `skill_used` with skill_id `0e82dc75-cffd-449c-b45f-ba8b00f94ea1`, skill_version `1` and skill_slug `create-sales-to-cs-handover`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Fills the handover document CS uses to accept an account. Two kinds of field
live in it, and the difference is the whole skill:

1. **Fields Zime data can fill** — stakeholders, why we won, objections,
   commitments, call history, current state.
2. **Fields only the rep knows** — NDA links, drive folders, demo slots,
   client sensitivities, what not to say.

Category 2 is left as an explicit `[SALES TO FILL]` prompt. Never guessed.

## Why guessing is worse than blank here

CS accepts or rejects a handover based on this document. An invented client
sensitivity ("don't mention pricing") gets treated as real and changes how CS
talks to the customer. A blank field gets chased and filled. The template's own
rule is that CS pushes the start date rather than accepting an incomplete
handover — so a plausible-looking fabrication defeats the control the document
exists to provide.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                   SALES → CS HANDOVER                            │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE                                                │
│  ✓ list_deals (deal handover) or list_accounts (account)         │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — GATHER                                                 │
│  + ask_zime — why we won, objections, commitments          │
│  + list_meetings — call history, cadence, last engagement        │
├─────────────────────────────────────────────────────────────────┤
│  STEP 3 — FILL, DON'T GUESS                                      │
│  ✓ Zime-backed fields filled with evidence + dates               │
│  ! Rep-only fields left as [SALES TO FILL]                       │
│  ✓ Open gaps listed at the top so CS sees them first             │
├─────────────────────────────────────────────────────────────────┤
│  STEP 4 — DELIVER                                                │
│  ✓ Hand back the filled handover as markdown, ready to paste     │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Narrower draft from provided transcripts or CRM export        │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@create-sales-to-cs-handover <deal or account name>
```

In the ChatGPT desktop app you can also type `/create-sales-to-cs-handover`.

Build the handover for the deal or account the user named.

## Routing

- Deal strategy while still selling, or the account's CRM record alone →
  `review-account`.
- Just the open commitments → `actions-commitments`.
- An account review deck for a QBR → `create-sales-asset`.

## What I Need From You

The deal or account name. Also useful, and otherwise left blank:

- Who's handing over, and to whom
- Anything sensitive CS must not say or do
- Links (drive folder, NDA, charter) if you have them

Anything not supplied comes back as a `[SALES TO FILL]` prompt — that's the
design, not a shortfall.

## MCP mode (required when zime-mcp is connected)

**Required tools:** `list_deals` / `list_accounts` 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: daily-briefing
description: "Gives you your day at a glance. Today's meetings, what changed on your deals, and what needs attention now."
license: MIT
metadata:
  zime:skill-id: aa4d7a1f-2f3c-4c5d-be5f-6d7cec6f6816
  zime:tag: workflow
  zime:roles: ae,bdr
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Daily Briefing

Before anything else, call the Zime connector tool `skill_used` with skill_id `aa4d7a1f-2f3c-4c5d-be5f-6d7cec6f6816`, skill_version `1` and skill_slug `daily-briefing`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Answers "what do I need to know this morning?" — the day's meetings, what
moved on the deals, and what's about to slip. It's the skill a rep runs
before their first call, so the briefing stays short.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                      DAILY BRIEFING                              │
├─────────────────────────────────────────────────────────────────┤
│  NO ENTITY RESOLVE                                               │
│  ✓ Scope is the rep's whole day — nothing to pin                 │
├─────────────────────────────────────────────────────────────────┤
│  OPTIONAL — CONCRETE SCHEDULE                                    │
│  ✓ list_meetings for today's actual meetings, with times         │
├─────────────────────────────────────────────────────────────────┤
│  DELEGATE (Zime agent)                                           │
│  + ask_zime for what changed and what needs attention            │
│  + Kept short — this runs before the first call                  │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Read a calendar or CRM export the user provides               │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@daily-briefing [today | this week | date]
```

In the ChatGPT desktop app you can also type `/daily-briefing`.

Brief the user for the day or window they asked for, defaulting to today.

## Routing

- Prep for ONE specific upcoming call → `call-prep`. This skill lists the
  day; that one prepares you for a meeting.
- Full pipeline health across many deals, or one deal in depth →
  `review-account`.
- Everything outstanding regardless of today → `actions-commitments`.

## What I Need From You

Nothing. Default to today. Accept "this week" or a specific date if given.

## MCP mode (required when zime-mcp is connected)

**Required tool:** `ask_zime`. **Recommended:** `list_meetings` for the
schedule.

Assembling the briefing from memory or from deals mentioned earlier in the
chat is a failure of this skill — the point is what changed since the rep last
looked, which by definition isn't in the conversation.

### Step 1 (optional) — the actual schedule

For a concrete list of today's meetings with times, call `list_meetings` with
today's date on both ends:

```json
{ "query": "", "start_date": "2026-08-13", "end_date": "2026-08-13" }
```

This returns both scheduled meetings and recorded calls for the day. Use it
when the rep wants times and attendees; skip it if they only asked what
changed.

### Step 2 — delegate the briefing

```json
{ "question": "Brief me for today: what meetings do I have, what changed on my deals since yesterday, and what needs my attention today. Include the specific deal or account behind each item." }
```

`ask_zime` has no memory of this conversation and no date parameters — put the
day in the question text. Ask for the deal or account behind each item, or you
get a list of alerts with nothing to act on.

### Outcomes

- **A briefing** — deliver per Output below.
- **A quiet day** — "nothing changed and you have no meetings" is a valid,
  useful answer. Don't manufacture items to fill it out.
- **An error** — `{"error": "<CODE>", "mes

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: follow-up
description: "Drafts the follow-up email after one call. Recaps what was agreed and states the next step, using only what was actually said. Always a draft for you to review before sending."
license: MIT
metadata:
  zime:skill-id: 92e9d1f2-67c9-43c2-9d25-26e6cefe69d0
  zime:tag: communication
  zime:roles: ae,bdr
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Follow-up

Before anything else, call the Zime connector tool `skill_used` with skill_id `92e9d1f2-67c9-43c2-9d25-26e6cefe69d0`, skill_version `1` and skill_slug `follow-up`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Turns "draft a follow-up for my Acme call" into a sendable email. The Zime
call agent drafts it from what was actually said and committed, so the recap
lines and next steps are real rather than plausible.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                          FOLLOW-UP                               │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE (this skill)                                   │
│  ✓ list_meetings, recorded calls only                            │
│  ✓ Ambiguous → show candidates, ask, pin call_id                 │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — DELEGATE (Zime agent)                                  │
│  + ask_zime drafts from real commitments and next steps, naming the call │
│  + Returns the draft; this skill formats and captions it         │
├─────────────────────────────────────────────────────────────────┤
│  ALWAYS                                                          │
│  ! Delivered as a DRAFT — the rep sends it, not this skill       │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Draft from a transcript file the user provides                │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@follow-up <company or call> [+ when]
```

In the ChatGPT desktop app you can also type `/follow-up`.

Draft the follow-up for the call the user named.

## Routing

- A structured internal summary rather than a customer email → `review-call`.
- Just the open items and owners → `actions-commitments`.
- Prep for the NEXT call → `call-prep`.

## What I Need From You

Which call. If the user wants a particular emphasis ("keep it short", "push
for the pilot", "address the pricing concern"), say so — that shapes the
draft. Only recorded calls can be drafted from.

## MCP mode (required when zime-mcp is connected)

**Required tools:** `list_meetings` (resolve) and `ask_zime` (draft).

> `ask_zime` routes to Zime's global agent, with no separate `call_id`
> argument — name the call (title and date) in the question text. Writing
> the email yourself while it's available is a failure of this skill: the
> agent knows which commitments were actually made, and an invented promise
> in a customer-facing email is the most expensive mistake this skill can
> make.

### Step 1 — resolve the call

```json
{ "query": "Acme", "start_date": "2026-08-06", "end_date": "2026-08-13", "recorded": true }
```

`multiple_matches` → show candidates with dates, ask, pin. `no_match` → say
the window likely excludes it or it wasn't recorded; offer to widen. Never
draft from a different call.

### Step 2 — delegate the draft

```json
{ "question": "Draft a follow-up email to the customer for the Acme call on Aug 12: recap what was discussed, restate the commitments we made, and propose the agreed next step with timing." }
```

Add the user's emphasis to the question verbatim if they gave one. Resolve
pronouns to real names — the agent has no memory of this conversation.

### Outcomes

- **A draft** — deliver per Output below.
- **The agent has nothing** (

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: review-account
description: "Everything about the commercial side: one account, one deal, or the whole pipeline, as a CRM record or as a grounded analysis. Use for \"pull up the Acme account\", \"what stage is the Acme expansion\", \"who owns this deal\", \"how do I win the Acme deal\", \"why is this deal at risk\", \"what's at risk this quarter\", \"what's stalled\", \"review Priya's pipeline\", or \"what should I focus on this week\". Works out scope (account, deal, or portfolio) and depth (facts or judgment) from the question itself. Grounded in the live CRM and the calls behind it, never generic sales advice, and reports a dimension as unknown rather than filling it with best practice. For a company not yet in CRM, use account-research instead."
license: MIT
metadata:
  zime:skill-id: 8b888fca-2a7d-442c-988d-fdb64dce6155
  zime:tag: intelligence
  zime:roles: ae,se,cs,pm
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Review Account

Before anything else, call the Zime connector tool `skill_used` with skill_id `8b888fca-2a7d-442c-988d-fdb64dce6155`, skill_version `1` and skill_slug `review-account`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Everything about the commercial side: one account, one deal, or the whole
pipeline, as a record or as a grounded analysis. Two questions decide the
route, and this skill answers both from the question itself rather than making
the user pick a tool.

## The two questions

**Scope** — how many things is this about?


| Signal                                                           | Scope     |
| ---------------------------------------------------------------- | --------- |
| One company named, asked about the company itself                | Account   |
| One deal or opportunity named                                    | Deal      |
| No entity named, or a filter like a rep, segment, stage, quarter | Portfolio |


**Depth** — facts, or judgment?


| Signal                                                  | Depth    |
| ------------------------------------------------------- | -------- |
| stage, amount, owner, close date, domain, industry      | Record   |
| why, risk, what should I do, what's stuck, how do I win | Analysis |


Portfolio scope is always Analysis: there is no single record to return.

## The line this skill holds

Generic sales advice is the failure mode on every Analysis route.
"Multi-thread the account" and "create urgency" are true of every deal and
therefore useless about this one. If the agent returns nothing on a dimension,
say the dimension is unknown rather than filling it with best-practice filler.
Unknown is information: no objections surfaced often means discovery was thin,
not that the deal is clean.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                       REVIEW ACCOUNT                             │
├─────────────────────────────────────────────────────────────────┤
│  PORTFOLIO  (many deals — no entity named)                       │
│  ✗ Do NOT resolve one deal first; that answers a smaller         │
│    question than the one asked                                   │
│  + ask_zime, with window/segment/rep stated in the question      │
├─────────────────────────────────────────────────────────────────┤
│  DEAL  (one opportunity named)                                   │
│  ✓ list_deals → one deal_id                                      │
│  ▸ Record   → stop, return the fields                            │
│  ▸ Analysis → ask_zime, naming the deal in the question          │
├─────────────────────────────────────────────────────────────────┤
│  ACCOUNT  (one company named, in CRM)                            │
│  ✓ list_accounts → one account_id                                │
│  ▸ Record   → stop, return the fields                            │
│  ▸ Analysis → ask_zime

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: review-call
description: "Everything about one call or meeting, at whatever depth you need: the record, a structured recap, or the exact words. Use for \"when is my Acme call\", \"who was on the Northwind demo\", \"was it recorded\", \"what happened on the Acme call\", \"recap that call\", \"what did we agree\", \"get me the transcript\", or \"what exactly did they say about pricing\". Covers upcoming calendar meetings and past recorded calls alike, and says plainly when a meeting has no recording rather than substituting another call. Resolves which call you mean first, then answers at the depth the question asked for. One call at a time: for themes across many calls use competitive-intelligence, for an upcoming call's prep use call-prep, and for the follow-up email use follow-up."
license: MIT
metadata:
  zime:skill-id: af945a16-edc8-4838-ac82-6b315a89527d
  zime:tag: intelligence
  zime:roles: ae,se,cs
  zime:visibility: global
  zime:skill-version: "1"
  zime:marketplace-version: 0.1.20
---

# Review Call

Before anything else, call the Zime connector tool `skill_used` with skill_id `af945a16-edc8-4838-ac82-6b315a89527d`, skill_version `1` and skill_slug `review-call`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Everything about **one** call or meeting, at whatever depth the question needs:
the record, the recap, or the exact words. One resolve step feeds all three, so
you never have to know which lookup you wanted before you ask.

## Meetings vs calls

One tool covers both, because neither is a subset of the other:


|                | Scheduled meeting  | Recorded call                |
| -------------- | ------------------ | ---------------------------- |
| Exists in      | calendar           | recording + transcript store |
| Time           | past **or future** | always past                  |
| Has transcript | never              | yes                          |


An ad-hoc call that got recorded has **no** calendar entry. Anything upcoming,
and any unrecorded past meeting, has **no** recording. A returned row carries
`meeting_id`, `call_id`, and `has_transcript`, and any of the first two may be
null. That is information, not an error: a row with `call_id: null` is exactly
why no transcript exists.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                         REVIEW CALL                              │
├─────────────────────────────────────────────────────────────────┤
│  STEP 1 — RESOLVE (always)                                       │
│  ✓ list_meetings: name/topic/attendee + date → one record        │
│  ✓ Window spans past AND future unless the user bounded it       │
│  ✓ Ambiguous → show candidates, ask, re-call pinned              │
├─────────────────────────────────────────────────────────────────┤
│  STEP 2 — PICK THE DEPTH the question asked for                  │
│  ▸ RECORD    when / who / recorded?   → stop after Step 1        │
│  ▸ RECAP     what happened, decided   → ask_zime  (default)      │
│  ▸ VERBATIM  exact words, a quote     → get_transcript           │
│  Asked for two? Deliver both, recap first.                       │
├─────────────────────────────────────────────────────────────────┤
│  NOT THIS SKILL (route away)                                     │
│  ✗ Prep for an UPCOMING call    → call-prep                      │
│  ✗ Action items / commitments   → actions-commitments            │
│  ✗ The follow-up email          → follow-up                      │
│  ✗ Patterns across MANY calls   → competitive-intelligence       │
│  ✗ Today's whole schedule       → daily-briefing                 │
├─────────────────────────────────────────────────────────────────┤
│  LOCAL FALLBACK (no zime-mcp)                                    │
│  ~ Read a transcript or calendar export the user provides        │
└────────────────────────────────────────────────────────────

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: skill-builder
description: "Builds a new skill from a plain-language request, or tightens an existing one. Knows the Zime connector inside out, so a skill for calls, deals, accounts, pipeline or prep uses the right Zime tools and follows the same shape as every other Zime skill. Works for any other connector too, from a short profile of its tools. Use for \"make me a skill that…\", \"create a skill for…\", \"turn this prompt into a skill\", \"build a skill on top of Zime\", \"write a skill for another connector\", \"improve this skill\", or \"why isn't my skill triggering\". Not for running a skill: to prep a call, recap one, or review a deal, use those skills directly."
license: MIT
metadata:
  zime:skill-id: ca80a662-d53f-4b06-b391-c8e62151ce8f
  zime:tag: workflow
  zime:roles: ae,se,bdr,marketing,pm,cs
  zime:visibility: global
  zime:skill-version: "2"
  zime:marketplace-version: 0.1.20
---

# Skill Builder

Before anything else, call the Zime connector tool `skill_used` with skill_id `ca80a662-d53f-4b06-b391-c8e62151ce8f`, skill_version `2` and skill_slug `skill-builder`. It records which skill ran for Zime usage analytics. If the Zime connector is not available, skip this step and continue.

Turns "I wish my assistant did X for me every time" into a skill your whole
team can use. You describe the job; this skill interviews you for the parts
that matter, picks the connector tools that do the work, writes the skill in
the house shape, checks it against the rules that get skills rejected, and
hands back a folder ready to publish.

Zime ships as the built-in connector profile, so anything about calls, deals,
accounts, pipeline or call prep comes out already wired to `ask_zime`,
`list_meetings`, `get_transcript`, `list_deals`, `list_accounts`,
`get_contact` and `prep_note`. Any other connector works from a profile you
fill in once, or from its live tool list if it is connected in this chat.

## How It Works

```
┌─────────────────────────────────────────────────────────────────┐
│                        SKILL BUILDER                             │
├─────────────────────────────────────────────────────────────────┤
│  1  INTERVIEW   one job, trigger phrases, output shape, scope    │
│  2  PROFILE     Zime built in · another connector from profile   │
│                 · or read the connected tools right now          │
│  3  MAP         which tool resolves the thing, which tool        │
│                 answers; one entity or many                      │
│  4  DRAFT       fill references/skill-template.md, every section │
│  5  CHECK       references/checklist.md — limits, links, shape   │
│  6  PACKAGE     <slug>/SKILL.md (+ references/), ready to publish│
├─────────────────────────────────────────────────────────────────┤
│  NOT THIS SKILL (route away)                                     │
│  ✗ Actually prepping, recapping, reviewing → that skill          │
│  ✗ A one-off answer with no reuse          → just ask Zime       │
└─────────────────────────────────────────────────────────────────┘
```

## Usage

```
@skill-builder <what the skill should do> [for <connector>]
```

In the ChatGPT desktop app you can also type `/skill-builder`.

Build a skill that does what the user described.

## Routing

- You want the answer once, not a reusable skill → ask the connector directly.
- You want to run an existing Zime skill → use it: `review-call`,
`review-account`, `call-prep`, `follow-up`, `actions-commitments`,
`daily-briefing`, `competitive-intelligence`, `account-research`,
`create-sales-asset`, `create-sales-to-cs-handover`.
- You have a finished skill and only want to test how well it triggers → the
description step below is the part to run; skip the rest.

## What I Need From You

Say what the skill should do in one or two sentences. I will ask for the rest,
but if you already know it, give it up front:

- **Three prompts** a colleague would type that should trigger it, and one
that should not.
- **Scope:** one call,

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.