@datasynx/agentic-crm

Datasynx Agentic CRM · dxcrm

The CRM your AI agents actually run.

Local-first. MCP-native. One autonomous agent per customer. Your pipeline lives as plain Markdown on your machine — and your AI agents read, reason about, and update it natively inside Claude Code, Codex, and Cursor.

Quickstart · Docs · npm · GitHub · LinkedIn

You don't open a CRM to find your customer. Your customer's agent finds you — briefed, current, and ready to act.

Your AI agents are brilliant — and forgetful. Datasynx Agentic CRM is the long-term memory and the hands they use to run your customer relationships. Every customer is a folder of human-readable Markdown on your own disk; 111 purpose-built Model Context Protocol tools let any agent load full context, score deals, forecast revenue, draft the follow-up, and log what happened — without you copy-pasting a thing.

No database. No cloud lock-in. No per-seat pricing. Zero telemetry.

See it in action

You    ▸  What's going on with Acme Corp?

Agent  ▸  ⟢ get_customer_context · get_deal_health · get_relationship_health

          Acme Corp — Negotiation · €75,000 · deal health B (78/100)
          • Last touch 2 days ago — pricing pushback from the CFO
          • Champion: VP Engineering (warm)   ⚠ Economic buyer quiet for 11 days
          • Next best action: send the ROI one-pager, loop the VP Eng into the thread

You    ▸  Draft that follow-up and log it.

Agent  ▸  ⟢ draft_email · log_interaction
          ✓ Draft ready (personalized from your "ROI follow-up" template)
          ✓ Logged to customers/acme-corp/interactions.md

Every answer is grounded in Markdown files you own and can open in any editor. Nothing is hidden in a vendor database.

How it works

flowchart LR
    You["🧑 You"] --> Agent
    Agent["🤖 Claude Code · Codex · Cursor"] <-->|Model Context Protocol| MCP

    subgraph local["🔒 Your machine"]
        MCP["⚙️ dxcrm MCP server<br/>111 typed tools · RBAC · audit"]
        Files["📁 objects/ (Company · Contact · Lead · Deal)<br/>+ customers/&lt;name&gt;/ (main_facts · interactions)"]
        MCP <--> Files
    end

    MCP -. you configure .-> Ext["✉️ Gmail · Outlook · Drive · Meet"]

	Step	What happens
01	dxcrm init	Detects & wires up Claude Code, Codex, Cursor, Claude Desktop — one command. Seeds starter email templates & a sequence so outreach works on day one. Reconciles an older vault's shape version (re-stamps .agentic/config.json / schema.json / sources.json to the current version; never downgrades a newer one). All harness/skill markdown (CLAUDE.md, AGENTS.md, GEMINI.md, SOUL.md, SKILL.md, TOOLS.md, Cursor .mdc) is written inside a delimited managed block, refreshed in place on re-init and never clobbering your own content.
02	Bring your data	dxcrm create, import from HubSpot/Salesforce/Pipedrive/CSV, or sync Gmail.
03	Just ask	Your agent briefs you, drafts emails, forecasts, and logs — grounded in your files.

Works with  ·  🟣 Claude Code  ·  🟢 Codex  ·  🔵 Cursor  ·  🟠 Claude Desktop  ·  🔌 any MCP client
_{If it speaks the Model Context Protocol, it's connected.}

Datasynx Agentic CRM is right for you if

• ✅ You live in Claude Code / Codex / Cursor and want your CRM there too — not in another browser tab.
• ✅ You want customer data as plain files you own, versionable in Git, readable forever.
• ✅ You're done pasting context into prompts — your agent should already know the account.
• ✅ You want deal scoring, forecasting, and next-best-actions on demand, not a quarterly export.
• ✅ You care about privacy & GDPR — local-first, built-in erasure, and zero telemetry.
• ✅ You want a CRM you can fork and extend in TypeScript, not file a feature request and wait.

Features

📁 Markdown-native data First-class typed objects — Company, Contact, Lead, Deal — live as UUID-keyed Markdown records under objects/, alongside per-customer main_facts and interactions. Every record carries a shared agentic block (actor attribution, provenance, soft-delete, version). Git-friendly, grep-able, yours forever.	🔌 111 MCP tools Typed tools for context, deals, comms, and intelligence — discoverable by agents via get_capabilities.	🧠 Deal & relationship IQ Deal-health grades, relationship graphs, champion/blocker maps, and next-best-action recommendations.
📈 Revenue forecasting Weighted pipeline plus a Monte Carlo simulation (P10/P50/P90) and at-risk-revenue analysis.	✉️ Comms that close Email templates, multi-step sequences, HTML quotes, tickets with SLAs, and NPS/CSAT surveys. Outbound quotes, drafts, NPS/CSAT surveys, and sequence fills are locale-aware — they follow the customer's language, auto-detected from inbound email.	🔎 Hybrid memory Vector + full-text search across every synced email, call transcript, and email attachment — PDFs, Office docs and images converted to Markdown and indexed on-device (LanceDB).
🔐 Enterprise controls Role-based access, a tamper-evident hash-chained audit trail (`dxcrm audit --verify`), an AES-256-GCM credential vault, and an EU AI Act Art. 14 governance surface — a global stop switch, decision override/rollback, and an empirical confidence-calibration harness (`dxcrm govern`).	🛡️ Privacy by design Local-first storage, one-command GDPR erasure, and zero telemetry.	🤖 Wake-triggered agents An agent per customer pings you (Telegram) the moment a relevant email lands.
💬 Omnichannel inbox Two-way embeddable web chat and WhatsApp Cloud API in one thread-based inbox — rate-limited, honeypot-protected, escalates to tickets.	📅 Scheduler & portal A native booking page with real free/busy slots and a customer self-service portal — no Calendly, no extra tools.	🩺 Live-readiness checks dxcrm doctor --integrations --live verifies every provider (Graph, Google, WhatsApp, Stripe, …) with a concrete fix hint per gap — including a calendar-freebusy line that flags when booking availability is the local-first all-free fallback (no calendar wired) rather than verified free/busy.

Without vs. with Datasynx Agentic CRM

Without	With
❌ You paste account context into every prompt — and still miss things.	✅ One MCP call loads the full, current briefing. The agent already knows the account.
❌ Per-seat SaaS; your customer data lives in someone else's cloud.	✅ Free & open source (MIT). Data is plain Markdown on your machine.
❌ Switch to a separate CRM UI to update a deal.	✅ Your agent updates the pipeline in place, from inside Claude Code / Codex / Cursor.
❌ "What exactly did we promise Acme in March?"	✅ Hybrid search over every synced email and transcript answers in seconds.
❌ Forecasting means wrangling a spreadsheet.	✅ Weighted + Monte Carlo forecast on demand, with at-risk revenue flagged.
❌ A security/GDPR review triggers a fire drill.	✅ dxcrm security-report, built-in GDPR erasure, RBAC, and audit logging out of the box.

Why it's different

Local-first by default.	Customers are Markdown folders on your disk. No database to run, no cloud to trust.
MCP-native, not bolted-on.	Agents call typed tools — not a scraped UI — with RBAC and an audit trail on every write.
Grounded answers.	Every response traces back to files you can open and verify. No hallucinated pipeline.
Hybrid recall.	Vector + full-text search over your synced inbox and call transcripts, fully on-device.
Zero telemetry.	The CLI and MCP server phone home to nothing. The only outbound calls are integrations you explicitly enable.
Crash- and concurrency-safe writes.	Every durable write goes through an in-process queue → a cross-process advisory lock → an atomic temp-file rename, so concurrent processes (daemon, CLI, and agents) never lose an interaction (see docs/deployment.md).
Yours to extend.	MIT-licensed TypeScript. Fork it, add a tool, ship it.

What's under the hood

dxcrm is a CLI and an MCP server. One install gives your agents a complete revenue toolkit:

┌──────────────────────────────────────────────────────────────────┐
│                   dxcrm MCP server  ·  111 tools                    │
│                                                                    │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────────┐  │
│  │  Customer  │ │  Pipeline  │ │Relationship│ │   Forecasting   │  │
│  │  Context   │ │  & Deals   │ │   Graph    │ │ (Monte Carlo)   │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────────┘  │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────────┐  │
│  │ Email · Seq│ │  Quotes ·  │ │ Tickets ·  │ │ Knowledge Base  │  │
│  │  · Drafts  │ │  Booking   │ │  Surveys   │ │  & Playbooks    │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────────┘  │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────────┐  │
│  │   RBAC ·   │ │   GDPR ·   │ │ Encrypted  │ │  Goals · Agents │  │
│  │   Audit    │ │  Erasure   │ │   Vault    │ │  · Approvals    │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────────┘  │
└──────────────────────────────────────────────────────────────────┘
        ▲                ▲                ▲                ▲
  ┌─────┴─────┐   ┌──────┴─────┐   ┌──────┴─────┐   ┌──────┴──────┐
  │  Claude   │   │   Codex    │   │   Cursor   │   │ HTTP / team │
  │   Code    │   │            │   │            │   │   server    │
  └───────────┘   └────────────┘   └────────────┘   └─────────────┘

  Sync in:  Gmail · Outlook · Google Drive · Teams · Google Meet
  Import:   HubSpot · Salesforce · Pipedrive · CSV

→ Full reference: 81 CLI commands · 111 MCP tools

Governance surface (read-only)

The project's only web UI is a read-only governance surface served by the HTTP server at /governance. It projects four governance reads as server-rendered HTML (no SPA, no client JS), gated by the same HMAC token as the dashboard:

• /governance/review — records awaiting human review (least-confident first)
• /governance/approvals — open proposals, with approve/reject
• /governance/audit — recent audit events + the hash-chain status
• /governance/board — read-only Kanban board (cards link to gated tools)

It is read-only by contract: the only writes are approve/reject (via the approve_action engine) and the global STOP toggle. Mint a link:

dxcrm governance link --days 7
# → http://localhost:3847/governance?token=…  (requires: dxcrm server start)

The same reads are available to agents as MCP Resources: crm://governance/review, crm://governance/approvals, crm://governance/audit, crm://governance/board.

Autonomy tiers — autonomous vs. gated

Every side-effecting tool is classified in a tier-aware action registry:

• autonomous — reads, enrichment, and internal writes execute directly.
• gated — external comms, state-machine transitions, and irreversible actions return a Proposal + approval prompt and commit only after approve_action. Each tool also declares whether its effect is reversible; irreversible actions (e.g. send_followup, convert_lead) are flagged so you review before approving.

One engine handles it all: approve_action is the single human-in-the-loop tool, with a fail-safe decision window — an unanswered or expired proposal can never execute. run_deal_agent proposes/executes through this same path (no private queue). get_capabilities() lists every tool with its Tier and Reversible flag.

From the terminal, dxcrm approvals list|approve|reject <proposalId> works the same queue, dxcrm policy set <tool> <autonomous|approval_gated|escalation_trigger> [--slug] overrides an action's tier, and dxcrm proposals show <id> prints a single Proposal's full record.

Art. 14 human oversight — dxcrm govern

The EU AI Act Art. 14 oversight surface is one human-only, operator-run command group sitting on top of the stop switch and audit spine:

dxcrm govern status                       # STOP-switch state + governance posture (default)
dxcrm govern stop --reason "incident"     # GLOBAL kill switch — halts all agent activity (fail-closed)
dxcrm govern resume                       # release the stop switch
dxcrm govern override <decisionId> --approve --reason "manager confirmed"
dxcrm govern override <decisionId> --reject  --reason "not authorised"
dxcrm govern rollback <decisionId> --reason "wrong stage"  # reverse a reversible decision (refuses irreversible ones)
dxcrm govern explain <decisionId>         # render a decision's provenance from the audit ledger
dxcrm govern dpia [--out dpia.md]         # generate a DPIA scaffold from the live posture

Every override/rollback is recorded as a first-class governance event in the hash-chained audit ledger.

To keep an agent's tool surface small, tools are grouped into feature-area contexts of at most 10 each; a route_tools meta-tool switches the active set.

Every dxcrm command returns 1 on a missing prerequisite (no credentials) or missing target (unknown account/secret), so scripts can branch on $? — see Exit codes.

🚀 Quickstart

Requirements: Node.js ≥ 20. Free and self-hosted — no account required.

npm install -g @datasynx/agentic-crm

dxcrm init                                   # detect & configure Claude Code, Codex, Cursor, ...
dxcrm create "Acme Corp" --domain acme.com   # create your first customer
dxcrm contact add [e-mail] --name "Jane Roe" --slug acme-corp --primary  # set the primary contact
dxcrm association add --slug acme-corp --from contact:c1 --to deal:d1 --type is_champion  # typed bidirectional link

Team mode: point every detected harness at a shared HTTP MCP server instead of a local stdio process:

dxcrm init --team http://vm-ip:3847/mcp      # writes an http transport to each harness config

The URL is validated up front and each harness gets its native HTTP transport shape (Claude Code / Cursor / Windsurf / Cline / Claude Desktop: { "type": "http", "url": ... }; Codex: transport = "streamable_http"; Hermes: type: http; OpenClaw: transport: "streamable-http"; Antigravity: serverUrl; Grok: transport: { type: "http", url }). See docs/team-setup.md.

Run with Docker (self-hosted): the official image bakes in the CPU-only, slim setup and pre-warms the embedding model — zero footprint knowledge required:

docker run -d -p 3847:3847 -v "$PWD/crm-data:/data" \
  -e ANTHROPIC_API_KEY=sk-ant-... \
  ghcr.io/datasynx/datasynx-crm:latest   # MCP HTTP server on http://localhost:3847/mcp

See docs/deployment.md.

Now open your AI agent and ask: "What's the status on Acme Corp?" — you'll get a grounded, current brief in seconds.

Migrating? Bring your existing data with you:

dxcrm import ./hubspot-export/ --from hubspot   # also: salesforce · pipedrive · csv
dxcrm sync acme-corp                            # pull Gmail threads + transcripts
dxcrm reindex acme-corp                         # rebuild vector index + memory table + graph

dxcrm reindex <slug> is a forward-only rebuild of a customer's derived stores from their authoritative sources: it re-embeds the vector index from stored text (so an embedding-model switch needs no re-sync), rebuilds the memory_<object_id> table from the JSON memory sidecar, and replays interactions.md to rebuild the relationship graph. Scope it with --memory-only, --graph-only, or --docs-only.

Syncing Gmail also downloads every attachment, converts it to Markdown (PDF, DOCX, XLSX, PPTX, CSV, HTML, and images via on-device OCR), stores it under customers/<slug>/attachments/, links it from interactions.md, and indexes the text into LanceDB so it's semantically searchable. Export a complete, sendable bundle of all conversations and documents for a customer with the export_customer MCP tool (includeAttachmentContent: true).

Beyond Gmail, dxcrm mailbox sync connects any IMAP mailbox — Outlook/Office365, Fastmail, Yahoo, or a custom company inbox — and auto-routes every message to the right customer by sender/recipient domain (or to one customer with a slug). One mailbox connection, all customers populated, same attachment + search pipeline.

# One-time OAuth (Gmail & Microsoft 365 require it for IMAP in 2026):
dxcrm mailbox login gmail --user [e-mail]
dxcrm mailbox login microsoft --user [e-mail]

# Then auto-route the whole mailbox to customers by domain:
dxcrm mailbox sync --account gmail:[e-mail]

Tokens are stored locally and auto-refreshed. A password-based IMAP server works too (DXCRM_IMAP_HOST / DXCRM_IMAP_USER / DXCRM_IMAP_PASS).

Secrets — entered in your browser, never in the chat

API keys, portal passwords and access tokens should never be pasted into a prompt, where they'd flow through the LLM. Instead, your agent hands you a link to a local, browser-based credential vault:

You    ▸  I need to connect our Stripe account.
Agent  ▸  ⟢ get_vault_link
          → http://localhost:3847/vault?t=…  (expires in 15 min)
          Open it and paste your key there — it's encrypted locally; I never see it.

You enter the value in the browser; it's encrypted with AES-256-GCM straight into .agentic/vault.enc on your machine and is retrievable from there — the secret never passes through the AI. The link is served by the HTTP MCP server, gated by a short-lived token, and the master key (DXCRM_VAULT_KEY) lives only in the server's environment.

Secure by default: even though the team MCP server binds 0.0.0.0, the /vault routes are reachable from localhost only — a leaked link can't be used from another machine. Put it behind a trusted reverse proxy with DXCRM_VAULT_GUI_ALLOW_REMOTE=1.

dxcrm server start                 # serves the vault GUI at /vault
export DXCRM_VAULT_KEY=…            # master key (server env only)
dxcrm vault link                   # mint a browser link from the terminal
# or, headless / scriptable:
dxcrm vault set stripe_api_key sk_live_…   ·   dxcrm vault list   ·   dxcrm vault get stripe_api_key

Agents reach this via the get_vault_link MCP tool. They get a link to hand you — never the secret itself.

Pipeline time-travel & analytics

The daemon takes a daily snapshot of your whole pipeline, so dxcrm can answer the questions no spreadsheet-CRM gets right — and exposes each as both a CLI command and an MCP tool, so a human at the terminal and an AI agent get identical insight.

dxcrm pipeline changes      # what moved since last week? (won/lost/new/stage-moves/value)
dxcrm pipeline velocity     # where do deals get stuck? (stage dwell time, sales cycle, stalled deals)
dxcrm pipeline funnel       # where do deals leak? (stage conversion %, win rate, biggest leak)

• changes diffs the live pipeline against any past date — won, lost, new and removed deals, stage moves, value changes, and net open-value delta.
• velocity reconstructs each deal's journey to report average time-in-stage, the average sales cycle (first-seen → won), and which open deals are rotting.
• funnel builds a cumulative conversion funnel: how many deals reach each stage, stage-to-stage conversion, overall win rate, and the biggest leak.

Agents reach the same data via the get_pipeline_changes, get_pipeline_velocity, and get_pipeline_funnel MCP tools. No setup — it gets sharper every day the daemon runs.

Tags & Smart Lists

First-class tags are a typed registry, not free-text strings: every key follows a naming convention (enterprise, priority:high, q3-2026) and resolves to a registered tag, so the same vocabulary is shared across humans and agents.

Smart Lists are dynamic, query-time segments — a saved AND/OR filter whose membership is recomputed live on every read and never frozen, so a list always reflects the current state of the store.

dxcrm tag create priority:high --label "High priority"   # register a tag
dxcrm tag assign acme priority:high                       # tag a customer
dxcrm smartlist create hot-leads --name "Hot leads"       # save a segment definition
dxcrm smartlist run hot-leads                             # live membership, computed now

Agents manage the same definitions via the define_smart_list / delete_smart_list MCP tools and read live membership through the crm://smartlists and crm://smartlist/{id} Resources.

What it's not

Not another SaaS tab.	It lives inside your AI agent and your filesystem — not a browser dashboard you have to open.
Not a database.	Customers are Markdown folders. Back them up with cp, version them with git.
Not a chatbot wrapper.	111 typed MCP tools with RBAC and audit — not a single prompt pretending to be a product.
Not a data grab.	Zero telemetry. Your data never leaves your machine unless you wire up an integration.
Not lock-in.	MIT-licensed, plain files, export anytime. Leaving is a cp -r away.

Built for teams

Run dxcrm solo, or stand up a shared MCP server for the whole revenue org:

• Shared HTTP MCP server — dxcrm server exposes the same tools to every teammate's agent.
• Transport trust model — RBAC and bearer auth apply to the shared HTTP server. The default local stdio server has no bearer auth and is single-user: the actor is your DXCRM_ACTOR env var (and with no rbac.json or a system actor, RBAC is open access). Use the HTTP transport for any multi-user or networked deployment — see Deployment → Security Notes.
• RBAC — admin / manager / rep roles scope what each actor (and their agent) can read and write. A field_acl map in rbac.json additionally redacts restricted customer metadata fields per role on every context path (tool, resource, daemon notification). A static guard (__tests__/core/rbac-invariant.test.ts) asserts every gated tool's permission string exists in the allow-list, so a tool can never be silently locked out for all actors. RBAC is enforced at MCP dispatch, before input validation, so a denied caller always receives Access denied (never a schema-validation error that could leak a tool's enum values or required fields).
• Least-privilege dispatch gate — on the HTTP transport, every gated tool call passes a fail-closed pipeline before input validation: a per-identity rate limit, an untrusted-payload guard (size caps, control-char rejection, and rejection of identity/scope keys smuggled into arguments), and scope enforcement for agent identities against the operation-level crm:<object>:<verb> scopes their token grants. A missing high-privilege scope (delete/export/communicate) returns a just-in-time (JIT) grant elicitation instead of a hard denial — the owner approves once, and a single-use, short-TTL grant lets exactly the next call proceed; un-approved or expired grants fail closed.
• Agent identity management — register an agent identity (a stable actor_id, the human owner_id it acts for, a purpose, and standing crm:<object>:<verb> scopes) and manage its authority from the CLI: dxcrm actor register <name> --owner <id> --purpose <text> --scopes <csv>, then dxcrm actor grant/revoke <actor_id> <scope> and dxcrm actor list. Mint a scope-bearing, audience-bound bearer token for it with dxcrm mcp token --agent <actor_id> --scopes <csv> (the token's scopes must be a subset of the agent's grants). Revoke with dxcrm actor revoke-identity <actor_id>.
• SSO — authenticate via WorkOS.
• Audit & compliance — tamper-evident hash-chained audit ledger (typed AuditEvents, verifiable with dxcrm audit --verify), one-command GDPR erasure, and dxcrm security-report for vendor reviews.

→ See the Deployment and Team Setup guides.

FAQ

Where does my data live? In a folder you choose, as Markdown files. No database, no cloud. Back it up and version it like code.

Which AI tools work with it? Anything that speaks MCP — Claude Code, Codex, Cursor, Claude Desktop, and more. dxcrm init auto-configures the ones it detects.

Is it really free? Yes. MIT-licensed and self-hosted. No seats, no metering.

Can a whole team use it? Yes — run the shared HTTP MCP server with RBAC and SSO. See Team Setup.

Can I migrate from HubSpot / Salesforce / Pipedrive? Yes — dxcrm import brings in contacts and activity history. CSV is supported too.

Does it send my data anywhere? No telemetry, ever. The only outbound calls are the integrations you explicitly configure (e.g. Gmail) and the LLM your agent already uses.

Documentation

📖 Full docs site: datasynx.github.io/datasynx-crm

• Quickstart — real Gmail in 5 minutes
• CLI Reference · MCP Tools · Schemas
• Framework Integrations · Deployment · Team Setup
• Compliance

Development

git clone https://github.com/datasynx/datasynx-crm
cd datasynx-crm
npm ci

npm test               # Vitest (TDD) — 3,700+ tests
npm run build          # tsdown → dist/
npm run typecheck      # strict TypeScript
npm run lint           # ESLint (zero warnings)
npm run docs:generate  # regenerate the CLI/MCP reference from code
npm run docs:check     # verify all relative doc links & anchors resolve

New contributors: start with CONTRIBUTING.md (TDD workflow, Conventional Commits, docs generation). The published reference is generated from code and guarded by a drift test, so the docs can never fall behind what ships.

Roadmap

→ Full roadmap with milestones and exit criteria: ROADMAP.md

Shipped

• ✅ 111 MCP tools · 81 CLI commands · local-first Markdown store

• ✅ Hybrid (vector + full-text) search over emails & transcripts

• ✅ Sync: Gmail, Outlook, Google Drive, Teams, Google Meet

• ✅ Import: HubSpot, Salesforce, Pipedrive, CSV

• ✅ Deal health, relationship graph/health, Monte Carlo forecasting

• ✅ Email templates & sequences, quotes, tickets (SLA), NPS/CSAT, knowledge base

• ✅ RBAC, tamper-evident hash-chained audit (dxcrm audit --verify), AES-256-GCM vault, GDPR erasure (restore is GDPR-aware — it won't resurrect an erased customer; --allow-erased overrides, audited)

• ✅ Three deletion lifecycles: soft-delete (reversible, hidden from reads), dxcrm gdpr anonymize <slug> --confirm (PII scrub, record survives), dxcrm gdpr erase <slug> --confirm (Art. 17 hard-delete). The erasure log holds only a salted subject_ref (no plaintext slug), and dxcrm gdpr sweep purges/anonymizes soft-deleted records past the retention window (Art. 5(1)(e))

• ✅ Shared HTTP MCP server, SSO (WorkOS), outbound webhooks

• ✅ Wake-triggered per-customer agents (Telegram)

• ✅ Customer self-service portal, native meeting scheduler

• ✅ Omnichannel inbox: embeddable two-way web chat + WhatsApp Cloud API (rate-limited, honeypot-protected endpoints)

• ✅ Teams/Meet transcript auto-discovery & routing

• ✅ Live transcript subscriptions (dxcrm transcripts subscribe teams|meet)

• ✅ Per-provider readiness checks: dxcrm doctor --integrations [--live]

Hardening (current focus)

• 🔧 First external user: 7 days fully HubSpot-free

Exploring

• ⚪ More notification channels (Slack)
• ⚪ Optional read-only web dashboard
• ⚪ Additional LLM providers for on-device summarization
• ⚪ Community plugin marketplace

Community & Links

• 📦 npm — @datasynx/agentic-crm
• 💻 GitHub — datasynx/datasynx-crm
• 🐛 Issues — report a bug or request a feature
• 🔒 Security — report a vulnerability privately
• 🤝 Contributing — CONTRIBUTING.md · Code of Conduct
• 💼 LinkedIn — Datasynx AI

Github Star History

License

MIT © 2026 Datasynx

_{Built with TypeScript · Powered by the Model Context Protocol · Your data, your machine, your agents.}