CMP42 // ANNOUNCEMENT // 2026-10-15ALPHA RUNNING · BERLIN 52.52°N
// Announcement · Alpha 2026.10

CMP42 IS LIVE.
THE HEADLESS CRM FOR THE ERA IN WHICH AI IS THE UI.

A schema built for agents rather than for humans clicking. A Context + Models + Processes graph that ChatGPT, Claude, your team's assistant — and the one you have not chosen yet — can read and write against. As of today it is not a plan: it runs, with Design Partners on it.

Revised 15 October 2026. The announcement of 14 September described a programme that was opening. This version describes what is running — and, at the end, what is not in it yet.

CMP42 key visual — a small round character pushes a blue sphere through a round opening into a concrete cube that carries an orange 42 chip on its side. Bright daylight, pale slabs in the distance, reflections on a polished floor.
// Context goes in, and the system can act on it. The cube is the graph; the sphere is what you already know.

Something quiet has happened in the last twelve months. Ask a sales manager how they check the pipeline. A year ago the answer was "I open HubSpot." Today the honest answer is "I ask my agent to summarise it, and if the summary looks off, I open HubSpot."

Ask a partner in a consulting practice how they draft the follow-up note after a client call. A year ago it was Word. Today it is an assistant, with a paste of the meeting transcript and a "make it sound like me." The database has not moved. The workflow has.

The CRMs we have — HubSpot, Salesforce, Pipedrive — were designed on an assumption that turns out to be temporary: that a human would open the UI. Every field, every pipeline, every dashboard exists because someone was going to click on it. When the agent tries to read the same schema, it treats it like a chat history: it hallucinates the missing bits, it invents fields that were never declared, it fabricates a stage that is not in the pipeline. Not because the model is bad. Because the schema was not built for the reader.

The bet: CRM is a graph problem now.

CMP42 is what happens if you build a CRM knowing the primary reader will be an agent, and the primary writer will be a human helped by an agent.

It has three deliberately small parts:

1 · Context — the connected object graph

Contacts, companies, deals — yes. Also documents, meeting recordings, product briefs, playbooks. Every object has a typed identity. Every edge is named (contact knows company, contact owns deal, partner authored doc). Every field is addressable by URI. Every write is versioned and attributable.

The agent reads this like a database, not like a chat log. Ask it "who at Aspen owns the Q4 renewal and what was the last thing they published on this topic?" — the agent walks the graph and answers with citations, not with vibes.

2 · Models — the ontology you version like code

Sensible defaults for the CRM primitives. Then you extend. Models live in git-versioned YAML. A single command migrates them. Every model automatically becomes a set of MCP tools — get_contact, list_deals_at_stage, write_note_on_company — that any MCP-compliant client can consume.

Your ontology is a first-class product artefact. Not a Salesforce setting somewhere behind three tabs. Not a hidden schema owned by an ops team you never see.

3 · Processes — human-plus-agent workflows, observable

A process is a named sequence of steps. Some run on humans (a partner reviews a case note). Some run on agents (the assistant drafts the follow-up). Each step reads and writes to the graph. Each transition is logged. Each run is replayable.

You audit an agent's work the way you audit a git branch: what did it read, what did it write, at what token cost, and can you replay the same process against last month's snapshot and check whether the answer would have been different.

What is running today.

An announcement that describes a plan is cheap. So here is the part a Design Partner can open this afternoon. Everything in this list is on production on 15 October; nothing here carries a footnote.

  • The engine, on the production machine. Sixteen million contacts and twenty people working at the same time, no failed step, every jump and every save in milliseconds — measured with the machine it ran on. Your sheet does not get heavier as your business grows, and that is the whole reason a CRM can be cheap and fast at once.
  • Consent that survives the argument. The request form stores the exact wording you were shown and the version of that wording, not a tick in a box. A mail goes out and a person presses a button; opening the link confirms nothing. Withdrawal is one click in every mail, and the proof of both survives an erasure.
  • Your assistant works directly in the records. Point your own assistant at your workspace with a personal access token — locally or over the remote endpoint — and it lists your sheets and your CRM objects as separate things, reads them, and writes research back. Every write carries that person's token. Deleting stays with a signed-in person, never a command.
  • Your AI account, your contract. There is no shared platform key. You connect your own access, and the profile carries a checklist for the questions a data protection officer will ask first: training switched off, zero data retention, which endpoint, Art. 28 and Art. 30. Which provider you use is your architectural decision, not ours.
  • Research that cites. Ask about a person or a company and the answer comes back with sources, written into the sheet like any other value — attributable, versioned, reviewable. Available with an Anthropic account on your side.
  • Test data that admits what it is. On request, generated rows are marked generated test data - not real and stay marked. CRM objects never accept invented data at all.

How your data gets in and out is deliberately plain: through your own connectors or your assistant over MCP, through import and export, and through the API. A native connector for a specific system is partner work — that is what the Design Partner Program is for.

What we refuse to build.

The list is deliberate. It is also the reason CMP42 exists.

  • No forced UI. What we ship is the Podma Workbench and a migrations CLI. Your team already has an interface — it is called ChatGPT, Claude, Slack, or the app your engineers will build next month. CMP42 does not compete with it. CMP42 feeds it.
  • No "AI insights" layer. We ship no model of our own. You bring the account you trust. CMP42 gives it grounded context, your agent produces the insight. If we shipped a black box, we would be part of the problem we set out to fix.
  • No 200-field contact object. Defaults are lean. Extension is explicit. Silence is a feature.
  • No cookie banner, no third-party scripts. Same posture as everything else protagx ships. Data protection by design, EU-hosted, self-hostable if you want.

What we ship instead: MCP tools day one, REST + GraphQL parity, git-versioned models, replayable processes, and a boring API that gets out of the way.

What is not in it yet.

Three things are decided and on the way. If you are evaluating seriously, these are the ones worth knowing the date of:

  • Accounts are opened by a person. There is no self-registration. You ask, we read the request, and a workspace exists within a working day. During an Alpha that is a feature; it will not stay that way forever.
  • An erasure does not yet reach the change log. Removing a record reaches everything attached to it, and the trail stays — which is correct for evidence and incomplete for Art. 17. Making the trail verifiable while the personal values in it become unreadable is the next step, not a shipped one.
  • Roles are visible, not enforced. Tenant separation is enforced in the application and tested; per-field permissions are shown but not yet refused at the boundary. If your review needs them enforced, say so before you start, not after.

The Design Partner Program is open.

Twelve companies. Six months of Alpha, running since October 2026. Direct-Slack access to the founder, a monthly co-design call, priority feature requests, and the right to propose and name one MCP tool that ships to every future customer. Fixed price of €6,900 one-time. We ask for real usage and honest feedback in return.

→ Apply to be a design partner

Timeline.

The path to GA

NOW
Alpha running with the first Design Partners. Weekly release cadence.
Q4 2026
MCP tool surface stabilises. First case studies published.
Q1 2027
Beta opens to a broader waitlist. Self-hosted image published.
H1 2027
General availability. Published pricing takes effect. Design Partners keep their lifetime rate.

Who this is for.

Boutique consultancies whose competitive advantage lives in a framework they keep re-explaining. That framework becomes the context an agent uses on the next engagement.

Product-led B2B teams who want an agent to read a real customer's history before drafting the renewal note — not the generic summary that gets the account name wrong.

Agencies with AI ambitions already selling AI to their clients. Sell them the version that grounds on their real accounts, not the demo that hallucinates a competitor.

Anyone leaving HubSpot who wants lean data plus a real API, not another platform to migrate onto next year.

Why now.

Because the workflow already moved. Every honest CRM user I speak to has one of two setups: they have wired their CRM into an AI agent through a hop and a lot of Python, and the results are inconsistent because the schema was not built for agent reading; or they have given up and copy-paste transcripts into a chat window.

Either way, the CRM is not the tool that runs the day. It is the database that gets consulted after the fact. If that is the honest role, let us build it for that role.

"CRM UIs are dying. AI is the UI now. But AI without context is autocomplete on a hallucination."

CMP42 is the context. Berlin-built. Data protection by design. Self-hostable. Small enough to hold in your head, big enough to feed the agents you have not chosen yet.

The difference to September is that you can now stop reading about it and open it instead.

→ Apply to be one of the first twelve design partners.

About the author. Christian Schappeit runs protagx, a Berlin practice building production-quality digital systems for regulated industries. Fifteen years of wiring companies to CRMs, most of them not built for the AI they now depend on. Reach out at hello@protagx.com.

Cite this piece. Schappeit, C. (2026). CMP42 is live — headless CRM for the era in which AI is the UI. Revised edition, 15 October 2026. protagx. https://cmp42.com/blog/launching-alpha/

Licence This article is published under CC BY-NC-ND 4.0 — share it, in full and with credit. Quoting needs no permission. What that means exactly.