Voice
Crmy
By Operational customer context for AI agents. CRMy gives customer-facing agents trusted customer context and action boundaries in one briefing_get call. MCP-native. PostgreSQL-backed. Open source.
Install
npm install -gConfiguration Example
{
"tool": "briefing_get",
"arguments": {
"subject_type": "account",
"subject_id": "<resolved-account-id>",
"context_radius": "account_wide",
"format": "text",
"token_budget": 3000
}
}README
<p align="center">
<img src="https://crmy.ai/crmy-logo.png" alt="CRMy" width="120" />
</p>
<h1 align="center">CRMy</h1>
<h2 align="center">Operational customer context for AI agents.</h2>
<p align="center">
Before a customer-facing agent acts, it needs trusted context. CRMy turns meeting transcripts, emails, notes, CRM changes, and other raw customer context into the trusted briefing any AI agent needs before it acts.
</p>
<p align="center">
<strong>Messy customer context in. Agent-ready Signals, Memory, and action guidance out.</strong>
</p>
<p align="center">
<a href="https://www.npmjs.com/package/@crmy/cli"><img alt="npm" src="https://img.shields.io/npm/v/@crmy/cli?label=npm&color=2563eb"></a>
<a href="https://github.com/crmy-ai/crmy/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-0f172a"></a>
<a href="https://discord.gg/2HvmudDwE"><img alt="Discord" src="https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white"></a>
<a href="https://github.com/crmy-ai/crmy/releases"><img alt="Release" src="https://img.shields.io/badge/release-v0.9.0-16a34a"></a>
<a href="https://github.com/crmy-ai/crmy/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/crmy-ai/crmy?style=social"></a>
</p>
<p align="center">
<a href="#quickstart">Quickstart</a>
·
<a href="#demo-raw-context-to-agent-briefing">Demo</a>
·
<a href="#why-crmy">Why CRMy?</a>
·
<a href="#connect-agents-through-mcp">MCP</a>
·
<a href="docs/recipes/README.md">Recipes</a>
·
<a href="examples/README.md">Examples</a>
</p>
---
Sales, CS, support, and RevOps agents do not need another place to store context. They need to know what is true, current, evidenced, approved, and safe to act on.
That breaks down when customer context is messy:
- the CRM is stale or incomplete;
- the call transcript has the real blocker but no durable structure;
- renewal risk is implied across emails, meetings, and notes;
- the agent cannot tell evidence from inference;
- the next action needs approval before it touches a customer or system of record;
- nobody can explain afterward why the agent acted.
CRMy is the context engine for that gap.
It accepts **Raw Context**, resolves the customer, extracts evidence-backed **Signals**, keeps inferred Signals separate until evidence, readiness, and review requirements allow them to become typed **Memory**, and retrieves the right briefing and Action Context before an agent drafts, decides, requests approval, or writes back.
```text
Raw Context -> Signals -> Memory -> Briefing + Action Context -> Handoff / Writeback -> Audit Trail
```
A customer-facing agent should be able to ask one high-level question before work:
> What do I need to know about this customer, what is uncertain or stale, what am I allowed to do, and what evidence backs it?
CRMy gives that answer through agent tools, CLI, REST, and UI surfaces on top of PostgreSQL.
> **Run the demo agent check:** complete the [Quickstart](#quickstart), then verify the source-to-action loop. It is not just a CRM lookup. It resolves the customer, retrieves a briefing with Memory and Signals, surfaces reviewable context, and shows the evidence behind the agent-ready output.
>
> ```bash
> npx -y @crmy/cli agent-smoke
> npx -y @crmy/cli briefing "account:Northstar Labs"
> npx -y @crmy/cli action-context "account:Northstar Labs" --action customer_outreach
> npx -y @crmy/cli context signal-groups
> npx -y @crmy/cli context lineage --subject "account:Northstar Labs"
> ```
Star CRMy if you’re building customer-facing agents that need operational memory, scoped tools, and governed action. If you expect them to *reliably* interact with customers, they do.
---
CRMy does not replace your systems of record. Your CRM, warehouse, support desk, mailbox, calendar, and other tools remain where work happens and state is stored.
CRMy makes that state agent-operable.
```mermaid
flowchart LR
raw["Messy Raw Context\ntranscripts, emails, notes, sync"]
signals["Signals\ninferred claims + evidence"]
memory["Memory\nconfirmed customer truth"]
retrieve["One retrieval path\nbriefing_get / action_context_get"]
action["Agent action\nwith warnings + policy"]
audit_trail["Handoff / Writeback / Audit Trail"]
raw --> signals --> memory --> retrieve --> action --> audit_trail
```
TL;DR: Before an agent acts on a customer, CRMy can tell it what is known, what is stale, what is inferred, what is approved, what action is allowed, what system owns the record, and what evidence or audit trail will exist afterward.
CRMy is not just retrieval over customer data. It separates inferred Signals from confirmed Memory, tracks source evidence and freshness, applies actor scope and policy, and records proof when an agent acts.
## Why CRMy?
Most sales, CS, support, and RevOps agents can draft, summarize, and call APIs. They still struggle with the operational questions that matter before action:
- What do we actually know about this account or deal?
- Which claims came from evidence, and which are only inferred?
- What changed since the last call, email, sync, or agent run?
- Which Memory is stale, contradicted, or missing support?
- Is this actor/agent allowed to see or change this record?
- Does this action need approval before it touches our system of record?
- What receipt shows what happened afterward?
CRMy gives agents that operating layer.
## Who This Is For
CRMy is for builders creating sales, CS, RevOps, support, or other customer-facing agents that need to work with humans and revenue systems safely.
Use it when your agent needs to know account state, inspect evidence, remember durable customer context, respect user scope, act with the right warnings, request approval when risk requires it, or prepare governed CRM/writeback actions.
## The Agent Context Loop
CRMy is built around the loop every customer-facing agent needs before action: observe messy context, remember what is proven, and act with guardrails.
### 1. Observe Freely
Ingest customer context from calls, meetings, emails, notes, calendar activity, CRM/warehouse sync, REST, CLI, MCP, and manual Add Context flows. Source metadata can represent support, product, Slack, document, and custom sources when those systems feed CRMy through API, MCP, or future adapters.
Raw Context stays messy. CRMy resolves visible customer records, extracts evidence-backed Signals, and keeps receipts for what was processed, skipped, matched, or failed.
The same account-first resolver powers Raw Context, customer email, calendar/activity capture, and agent record lookup, so opportunities and use cases are matched inside the right account instead of guessed globally.
### 2. Remember Operationally
Store typed customer Memory for accounts, contacts, opportunities, use cases, stakeholders, risks, objections, commitments, next steps, buying process, success criteria, and forecast signals.
Memory is persistent, scoped, searchable, versioned, auditable, and designed for agent action. Signals remain separate until evidence, source quality, typed detail, policy, and readiness allow them to become confirmed Memory.
### 3. Act Safely
Brief agents before action, warn when context is stale or inferred, route sensitive decisions through Handoffs, enforce user and team scope, preview writebacks, apply policy, and emit audit receipts.
Agents can prepare work freely. CRMy decides what can proceed, what needs a warning, what can be written, what needs approval, and what must stay reviewable. That same boundary applies to manual actions, Workspace Agent actions, workflow-triggered actions, sequence sends, customer email drafts, and systems-of-record writeback.
## Core Concepts
| Concept | What it means |
|---|---|
| **Raw Context** | Source material before extraction: transcripts, emails, notes, calendar meetings, CRM changes, docs, support/product signals, and agent inputs. |
| **Signals** | Inferred claims with evidence, confidence, source lineage, and readiness. Signals can be confirmed, dismissed, or sent to review. |
| **Memory** | Confirmed operational customer context agents can rely on across sessions and workflows. Memory carries freshness and decay signals, so CRMy does not treat customer truth as permanent. |
| **Active Context** | The temporary working set an agent can see right now: prompt, conversation, bound record, retrieved briefing, tool results, and loaded files. |
| **Action Context** | Action guidance in one packet: readiness, policy, source authority, warnings, review requirements, and audit metadata before an agent prepares customer-facing or record-changing work. |
| **Handoffs** | Human review for approvals, escalations, uncertain Signals, and governed decisions. |
| **Writeback** | Policy-checked updates to systems of record through preview, approval, idempotency, audit, and execution receipts. |
Briefings answer “what should the agent know?” Action Context answers “is this action ready, allowed, risky, stale, or review-required?” When review is required, the human-unblock tool turns that packet into a tracked approval or assignment with proof attached.
## What CRMy Is Not
- Not a CRM replacement. Salesforce, HubSpot, warehouses, and support desks stay the systems of record.
- Not generic chatbot memory. CRMy stores typed, evidence-backed customer Memory with lifecycle, ownership, freshness, and audit.
- Not a workflow toy. Agents can prepare action, but CRMy keeps policy, Handoffs, writeback receipts, and human review in the path when risk requires it.
- Not a sales methodology lock-in. Registries and Memory types are extensible, so teams can model their own customer operating language.
## Architecture
```mermaid
flowchart LR
sources["Calls, emails, CRM, calendar, support, product, docs, MCP"]
raw["Raw Context"]
signals["Signals\ninferred + evidence-backed"]
memory["Memory\nconfirmed + typed"]
active
... (truncated)
voice
Comments
Sign in to leave a comment