Headless CRM

The problem

Software built for people clicking, used by something that doesn't click

Every business system assumes a person will be looking at it. An agent asked to work with one has three bad options — and companies are discovering all three the hard way.

Drive the screens

Point the model at the interface and let it click. Slow, expensive, and it breaks the week the vendor moves a button.

Wrap the API

Write a translation layer and teach the model every endpoint. Now you maintain that layer forever, and the model still guesses when the docs are thin.

Keep it in the prompt

Paste the context in each time. Works until there are more customers than fit, or two people need the same answer.

The assumption underneath all three is that the software was built for someone else and the agent is a visitor. This one was built the other way round.

What it is

A system of record whose only user is an agent

There is no app to log into day to day, no dashboard nobody updates, no fields to tab through. The interface is the protocol your assistant already speaks — so the thing doing the work talks to the system directly.

It explains itself

Nothing to integrate and nothing to teach.

An assistant that has never seen it asks what it can do, and is told — precisely enough to get it right the first time.
When something new is added, every connected agent can use it immediately. Nothing on your side to update.
A wrong guess is answered with the right one, rather than a stack trace.

One thread per customer

The thing a CRM is supposed to do, and usually doesn't.

Every call, email, meeting, note and promise about a person lands in one place — whoever, or whatever, recorded it.
Ask about someone and get the whole relationship back: their company, who is dealing with them, what was said, what is owed.
Write the same person twice and it says so, and points at the record already there.

Everyone works from the same memory

Your assistant, your colleague's assistant, and your colleague.

What one agent learns, the next one knows — including a different person's agent.
Nobody rebuilds context that somebody else already has.
People still get a place to read and export it all when they want to look for themselves.

It keeps up with how you speak

Written for the way people actually ask.

“Who haven't we spoken to in a month?” is a question it answers, not a report you build.
“Log that and chase it Friday” is one instruction, not four fields.
Bring years of old conversations with you; they get filed against the right people.

Trust

Safe to hand the keys to something autonomous

Letting software act on its own against your customer records is only reasonable if the system assumes it will sometimes get it wrong. This one does.

Everything is attributable

Every change records who made it — which person, through which agent.
An agent cannot claim to be someone else.
The full before-and-after of every edit is kept.

Everything is reversible

Deletes can be undone, and undoing one brings the history back with it.
A bulk change that goes wrong can be put back.
An action can be rehearsed first and thrown away.

It refuses to make a mess

Duplicate people are refused, with the record already there.
Someone who asked not to be emailed will not be emailed.
A destructive instruction that means “everything” has to say so out loud.

Access is deliberate

One credential per agent, revoked one at a time.
Remove someone and their agents stop working immediately.
Nothing is reachable without proving who it is.

Your data is yours alone

Every company using it is sealed off from every other.
Not by convention — by construction, at the point every read and write passes through.
Knowing an identifier gets an outsider nothing.

Retries are safe

An agent that repeats itself does not double-book anything.
A dropped connection does not leave half a change behind.
Work that belongs together succeeds together, or not at all.

Why now

The interface layer is changing hands

For thirty years the way to make software useful was to build a better screen. That assumption is quietly expiring: increasingly the thing sitting between a person and their tools is an assistant, and it wants a different kind of surface.

What agents need that people don't

To be told, not shown. A layout means nothing; a precise answer about what is possible means everything.
Memory that outlives the conversation. Otherwise every session starts from zero.
Guard rails that hold. Something acting quickly and confidently needs a system that says no.

What that buys you

No interface to maintain. The part of a CRM that usually rots is the part nobody fills in.
No integration to rewrite. Capability is discovered, not hard-coded.
Records that are actually kept. Because keeping them costs a sentence, not a form.

Start

Two minutes, and your assistant has a memory

Give any assistant that speaks the Model Context Protocol the address below. It handles the rest — signing in, working out what it can do, and getting on with it.

Point your assistant at it

once

claude mcp add --transport http crm https://headlesscrm-production.up.railway.app/mcp

Then simply ask

every day

"What do we know about Alicia at Northwind?"
"Log that call and chase it on Friday."
"Who have we not spoken to in a month?"
"Draft the follow-up she asked for."

Connect an agent → See what it can do