CMP42 // USE CASES // PRODUCT-LED B2BUSE CASE 02 OF 04
// Use case 02 · Product-led B2B teams

READ THE ACCOUNT.
THEN WRITE THE NOTE.

You want an agent that reads a real customer’s history before it drafts the renewal note. Not the generic ChatGPT summary that gets the account name wrong. That agent needs a graph, not a HubSpot export.

// The problem

THE EXPORT IS NOT THE ACCOUNT.

In a product-led business, the story of an account is spread thin: who signed up first, who became the champion, which deal is up for renewal, what the last review deck said, what the customer asked for on the last call. Some of it is in the CRM. Much of it is in documents, recordings and notes.

The common shortcut is to pipe a CRM export through a Zapier hop into whichever agent shipped this week. The agent receives rows of text. It cannot tell a champion from someone copied on an email, so it guesses. It fills in a field that was never declared. It mentions a pipeline stage that does not exist. Not because the model is bad — because the source was not built for the reader.

The result is a renewal note that sounds confident and is subtly wrong. Someone on your team catches it, or a customer does.

// Export vs graph

WHAT THE AGENT ACTUALLY RECEIVES.

A conceptual comparison of two ways to give an agent customer context. It describes the shape of the input, not any vendor’s features.

Export pasted into a promptCMP42 Context graph
ShapeFlat rows and text, read as one blobTyped objects with named edges, read like a database
RelationshipsImplied by column names; the agent infers themExplicit: a contact owns a deal, authored a document
FreshnessA snapshot from whenever the export ranThe current graph, with every object versioned
Missing dataEasy to paper over with plausible guessesDeclared fields only; writes are validated against your Models
CitationsHard to trace a sentence back to its sourceEvery object and field addressable by URI
Writing backCopy the draft somewhere by handMCP tools such as write_note, attributed and versioned
// How it works in CMP42

FOUR PIECES, ONE RENEWAL.

Context

The account as a graph

Company, contacts, the renewal deal, product briefs, meeting recordings and notes — connected by typed edges in the Context graph. Tools like get_context and list_related let an agent walk it.

Models

Only the fields you declare

Lean defaults for contact, company, deal, task and activity. The renewal-relevant fields your team actually uses are declared explicitly in Models — nothing more. If it is not in your ontology, it is not on the contact.

Processes

A renewal note with a human step

Wrap the draft in a Process: the agent reads and drafts, the account owner approves, the approved note is written back. Every run is logged and replayable against a past snapshot.

MCP

Any agent your team prefers

Claude Desktop, Claude Code, Cursor, Cline or a custom agent on the MCP SDK read the same tools. For the rest of your stack, REST and GraphQL expose the same operations with the same auth and audit trail. MCP tools →

// Scenario

BEFORE THE RENEWAL CALL.

Illustrative scenario

Drafting the Aspen renewal note

“Aspen” is a fictional customer. The steps show how the concepts fit together; tool names and the process format are illustrative and will be shaped with the Design Partners.

  1. The account owner asks her agent to draft the renewal note for Aspen ahead of next week’s call.
  2. The agent calls get_context on the Aspen renewal deal and list_related for the people and documents around it. It sees who owns the renewal, the current renewal plan document and the notes from the last two calls.
  3. It drafts the note from that history and lists the source objects it used. When it tries to set a deal stage your Models do not define, write-time validation returns a clear error and it corrects itself.
  4. A Process step routes the draft to the account owner. She approves it; write_note stores it, attributed to the agent and approved by her.
  5. Next quarter, the team replays the same process against last month’s snapshot to check whether the note would have said something different.
processes/renewal-note · sketchIllustrative
# illustrative — the idea, not the final syntax
process: renewal_note
steps:
  - agent: read_account   # get_context + list_related
  - agent: draft_note     # cites source objects by URI
  - human: approve        # account owner signs off
  - agent: write_note     # attributed + versioned
observe:
  run_history: replayable against a past snapshot
  cost: token spend per run
// What you get — and what you do not

GROUNDED DRAFTS. NO BLACK BOX.

What changes

  • Drafts grounded in the real account, with the source objects listed.
  • A human approval step exactly where your team wants one.
  • An audit trail per run: what the agent read, what it wrote, at what token cost.
  • One graph for every agent — the renewal assistant today, the support bot next quarter.

What CMP42 deliberately does not ship

  • No proprietary “AI insights” layer. Bring the model you trust. Why →
  • A start page that counts what is in there — records per object, deals by stage, recent changes — plus whatever you build against the API.
  • No 200-field contact object. Defaults are lean; extension is explicit.

Name the tool your renewals need

Design Partners can propose and name one MCP tool that ships to every future customer. Tell us on the 15-minute call what your renewal workflow is missing.

→ Apply to be a Design Partner
// Questions on this

What people ask here

The same answers as in the CRM FAQ, next to the case they belong to.

BAS-02

What does "headless CRM" mean?

Headless means there is no user interface you are forced to use. There is no pipeline builder and no form for every field. Instead, CMP42 provides a structured graph of Context, Models and Processes and a fast API that any agent can read from and write to.

For keyboard work on large data sets there is the Podma Workbench: views, filters and saved views across a million records and more. Your team stays in its own tools, whether that is Claude, ChatGPT, Slack or in-house apps, and CMP42 supplies them with context.

Prompts and sources for this question

BAS-03

What is MCP, and how does Claude connect to CMP42?

The Model Context Protocol (MCP) is an open standard that lets AI applications use tools and data. An MCP server describes each tool with a name, a description and a typed input schema. The client, Claude for example, discovers these tools at runtime, and the model decides when to call them.

CMP42 is MCP-native: every Model automatically becomes a set of MCP tools. You point Claude at your workspace, and it can read, write and plan against your real context. In practice:

  • Clients: Claude Desktop, Claude Code, Cursor, Cline and your own agents built on the MCP SDK.
  • Transport: local stdio for development and the CLI, or Streamable HTTP for hosted agents.
  • Access: a workspace-scoped API token in the MCP client configuration, limited to one workspace and named Models. OAuth 2.1 follows after GA.
  • Without MCP: Slack bots, internal apps and scripts use REST or GraphQL, with the same authentication and the same audit trail.

Prompts and sources for this question

SAL-04

How does a sales funnel differ from a sales pipeline?

The funnel is a model: it describes how many people reach each step on the way from first contact to purchase. The pipeline is concrete: it holds the real deals and their current stage.

In CMP42 the deal stages are declared in your Model, and tools such as list_deals_at_stage are generated from them. If an agent sends a stage that does not exist, it gets a clear error and corrects itself instead of inventing a stage. You build the funnel by having the agent count and compare the contacts’ lifecycle stages.

Prompts and sources for this question

Decided1
SAL-05

How do you calculate conversion rate and win rate with an agent?

The formulas stay the classic ones:

  • Conversion rate = the number who took an action / the number who could have taken it.
  • Win rate = won deals / all closed deals (won plus lost).

CMP42 has no built-in insights layer for this. The agent reads the deals with their stages and versions and does the arithmetic itself. Because every change is versioned, it can also say when a deal reached each stage. It can name the records a figure rests on, so every number can be traced back to the record.

Prompts and sources for this question

Decided1
DAT-02

How do Models work, and what do they have to do with MCP tools?

Models are your ontology: the list of business objects, their fields and their relationships. They are declared in a TypeScript-style YAML format, versioned in Git, reviewed like code and migrated with a single command.

On every migration CMP42 generates the matching MCP tools. Each Model gets six standard tools following a fixed pattern: create, read, update, delete, list and search, for example contact.create or deal.update. Models with tagged fields also get filter. Add a Model Engagement for consulting mandates, and Claude can list mandates by stage and write notes on them straight away, without anyone writing code.

Migrations are backward compatible, so tools that agents rely on in production keep working.

Prompts and sources for this question

Decided and on the way. Say which one you need first:

  • Open - you decide1Funnel metrics over MCP

All 43 questions in the CRM FAQ

¹ Planned for a future release.