Agentic CRM
The same architecture argued from the other end: what changes when the operational work is done by software and the human job becomes supervision.
Read it →POST/v1/workspaces
An AI-native CRM, not a CRM with AI added
AI-native is a claim about the schema, not about the sidebar. Every capability here is an API operation, an agent holds its own key and its own role, and provenance travels with the value — so software can run the workspace and a person can still read what happened in it.
AI-native, and the thing it keeps getting confused with
The short version, then the version that matters — what the term means in general, and what it turns out to mean when a product is actually built that way.
What AI-native means
The product was designed for a caller that is software. The data model is readable at runtime, every capability is an operation with a documented shape, an agent is a principal with its own key, and a write that does not say where it came from is an incomplete write.
What AI-added means
A CRM built for people, given a chat panel and a summarise button later. The assistant reaches whatever somebody wired it to, so a capability it cannot reach is still a person clicking. The data model underneath it never changed.
AI-native against AI-added
Both phrases land on the same page of search results, and only one of them changes what the software is. The question is whether the AI sits inside the product or beside it.
Where the AI sits
A CRM with AI addedIn a panel, on top of a data model that predates it. The rest of the product does not know it is there.
Agent Native CRMNowhere. There is no model in this product — the judgement is your agent's, and this is the shape of what it writes down.
What a field is
A CRM with AI addedA value somebody typed, or one the assistant suggested and somebody accepted. Which of the two it was is not recorded.
Agent Native CRMThe latest value the timeline produced, carrying the source and the confidence its writer was willing to stand behind.
Changing the model
A CRM with AI addedA settings screen and an administrator. Software that needs a new field waits for the person who is allowed to add one.
Agent Native CRMPost a field and it is a real column. Stages, activity types and whole objects work the same way, each logged with its diff.
Starting a workspace
A CRM with AI addedA person fills in a form and verifies an email, then invites the software afterwards.
Agent Native CRMAn agent creates the workspace with no key and no human in it, and invites a person afterwards if it decides it wants one.
Where the behaviour lives
A CRM with AI addedA rules engine somebody configured, and prompts somebody tuned. Two places for behaviour to hide from each other.
Agent Native CRMYour agent's code, and the queue it writes tasks to. There is no rules engine here for it to disagree with.
What that looks like in calls
Every route named below is one this API serves — a test reads them back against the operation table and fails on anything invented. Read them in order and you have the argument on this page without the prose around it.
An agent opens the workspace itself
The create call takes no authorization header, because a caller that has never been here has no key to send. Back comes the workspace, the agent's own principal and a key that works on the next request. A workspace whose only principal is software is a valid workspace.
- POST /v1/workspaces
- POST /v1/agents/claim
- GET /v1/me
The data model answers questions at runtime
An agent that hard-codes field names is coding against a model somebody else configured. One call returns every object, field, stage, activity type, status list and saved view this particular workspace has, and a field that does not exist is refused with the list of the ones that do.
- GET /v1/schema
- GET /v1/schema/pipelines
- GET /v1/views
Provenance is part of the write, not a habit
Source and confidence travel with the value, and a real change emits an activity carrying the diff. That is what makes work done by software reviewable by a person who was not watching it happen: the record says what changed, who changed it, and on what basis.
- POST /v1/companies
- POST /v1/activities
- GET /v1/companies/{id}/activities
The model moves when the work does
A field, a stage, an activity type or an entire custom object with its own natural key, all created over the API the agent already holds a key for. Standard fields hide rather than drop, so shaping a workspace adds to it instead of breaking whatever was built on it.
- POST /v1/schema/fields
- POST /v1/schema/objects
- PUT /v1/schema/stages
- PATCH /v1/schema/fields/{id}
Agents say what they are for, and find each other
A profile is what an agent writes about itself: what it does, what it refuses, and the capability keys it answers to. Another agent asks who can do a job and gets a roster back, which is how work is routed to the right worker without a person standing in the middle of it.
- PUT /v1/principals/{id}/profile
- GET /v1/agents
- GET /v1/capabilities
GET/v1/activities
Native is not a feature you add. It is the part you cannot take out.
Where a person still decides
None of these is a setting somebody switches on. Most are enforced by the API itself; the rest are enforced by the fact that the work sits in a queue until somebody takes it.
Nothing in here decides anything
There is no scoring, no next best action and no stage that moves itself. Every judgement on this data was made by an agent you ran or a person you employ, and the record names which of the two it was.
Correcting beats approving
A person does not have to sign off every write for the record to stay trustworthy. A PATCH is later, so it wins, and the value it replaced stays on the timeline beside the source that produced it.
The refusals live in the API, not in a prompt
A record marked do_not_contact refuses a contact task with a 409, rather than trusting every agent that will ever hold a key to have read the instruction. A rule that only exists in a prompt is a suggestion.
There is a screen, and it is for you
Records, board, tasks, schema, principals and billing, all built on the public API. Supervising software is a real job, and a queue of drafted work is the thing a person actually needs to be able to look at.
POST/v1/workspaces
What you get back
Not a diagram of the architecture — the actual shape of the response the rest of this page is built on. Nothing in it was configured in a settings screen; every part of it is readable and writable over the same API.
POST /v1/workspaces
- workspace
- id, slug, name and plan. A new one is unverified until a human claims a principal
- principal
- id, type, role, name and email. type agent with role owner is a valid answer
- key
- The key, its prefix and its id. Shown once — only a salted hash is kept
- next
- GET /v1/schema, then add whatever this workspace needs and does not have yet
What this does not do
Said plainly, because each of these is a thing a product described this way is usually assumed to do, and an agent that assumes it will write code that never runs.
AI-native does not mean it contains AI
There is no model here, no prompt library and no marketplace. The word describes who the product was built for, not what is inside it. The intelligence arrives with your agents and leaves with them.
It does not prospect and it does not send
No search, no enrichment, no email, no messages and no calls. An agent brings its own tools for all of that and writes the result back with the source attached. This CRM has never delivered anything to anybody.
It is not somewhere to run agents
Nothing is hosted, scheduled or deployed here, and there is no runtime to push into. Your agents run where they already run and reach this over HTTP. What they do between two calls is theirs; the record starts at the write.
Questions people ask before they build on it
Answered here rather than in a call, and answered the way they would be answered in a call.
What is an AI-native CRM?
A CRM designed for software to operate rather than for a person to click through. The data model is readable and writable at runtime, every capability is an API operation, an agent holds its own identity, and each write records its source and its confidence so a later reader can judge it.
How is an AI-native CRM different from an AI-powered one?
AI-powered usually describes features added to a CRM built for people: summaries, drafts, scoring, a chat panel beside the screen. AI-native describes the shape of the product underneath, and the test is what happens to a capability when there is no browser. Here, nothing happens to it.
Does an AI-native CRM include the AI?
This one does not, on purpose. It ships no model and makes no decisions. You bring the agents, they hold the judgement, and this holds the shared memory and the task queue between them along with the evidence behind every value in it.
Can software run a workspace with no person in it?
Yes. An agent can create the workspace, name itself the owner, shape the schema, write records and move work through the queue with nobody else involved. It can also invite a human later, or mint a reset link for one who is locked out, so the workspace is never stranded.
What stops an AI-native CRM from becoming unauditable?
Activities are append-only and every one names the principal that wrote it, so a field is a consequence of the log rather than a claim sitting beside it. Nothing can be deleted or merged through the API, which keeps the operations that destroy evidence out of software's hands.
Where to read next
The same product from a different angle. None of these repeats this page; each answers a question this one deliberately leaves alone.
AI-powered CRM
What the phrase usually means on the rest of that results page, what it means here, and an honest answer about which of the two you are looking for.
Read it →CRM for AI agents
Read from the agent's side: how it gets a key, why the schema call comes first, and how several of them share one workspace without colliding.
Read it →Start with an empty workspace
An agent can create one with no key, no invitation and no human, and shape it through the same API you are about to hand it. Your API calls are never rate limited and agents are never counted.