The category has a name because the shape of the work has changed. Three decades of customer relationship management under-delivered on customer centricity because the underlying model was wrong. Organisations siloed by function. Incentives across marketing, sales, and service misaligned. A system-of-record used by humans in manual workflows, tracking what humans remembered to type.
Customer Managed Relationships is the frame that fits the current shape. The centre of control moves from enterprise systems to the customer. Customer intent, permissions, and preferences become the orchestration layer. Enterprise systems become execution endpoints for customer-controlled agents.
CRM tracked activity. CMR computes on meaning. The next category has a different name for a reason.
What CRM was
Every business runs on moments that vanish the second they happen. Every email captured. Every touch counted. Dashboards filled with low-value records that humans skimmed and agents stumbled over.
The workflow ran in one direction. The rep updated the record; the manager reviewed the dashboard; the analyst exported the pipeline. Every step introduced latency, transcription loss, and the political cost of the person entering data getting nothing back for the effort. The reporting layer optimised for the retrospective board slide over the next decision.
Fragmented channel context stitched together after the interaction, if at all. The system sat downstream of the moment. The moment was already gone.
What shifted underneath
Customers already carry personal AI assistants. Vendors already ship headless agent APIs. External agent clients already reason over enterprise data on behalf of the human whose credential they carry. Machine-to-machine execution between customer agent and enterprise endpoint is happening whether or not the enterprise CRM is shaped for it.
The competitive question inverts. Winning a relationship becomes becoming the preferred machine-resolved option. Campaign-centric competition weakens against interoperability and execution quality. Support, sales, and service journeys become API outcomes before they become UI experiences.
What the substrate has to be
Every entity in Actionary publishes one shared schema definition — fields, types, relations, validations, capabilities. The product SPA reads it to render pages. The embedded agent reads the same definition to reason. External agents read the same definition through the same catalogue call. One schema. Humans see what the agent understands, without drift.
Every agent turn ships the tenant’s schema catalogue inside the system prompt, cached at the provider. The agent orients without spending tool calls on schema discovery. Workflows are agent-invokable as first-class objects — a new workflow is agent-accessible the moment it is defined, with no integration glue.
Tenant isolation lives in the database itself. Every tenant table carries a row-level policy the database enforces on every query, tied to the request’s tenant. A missed application-layer clause returns zero rows; another tenant’s data stays invisible.
The agent does the management
The agent inherits the calling user’s permissions — the same scope the human already has. Every agent write flows through the same access control, the same tenant boundary, and the same audit log as every UI action. An incident reviewer reconstructs an agent action exactly the way they reconstruct a human action.
Every multi-tool turn writes a reflection to the agent’s memory — a semantic embedding of the turn, ordered tool sequence, referenced entities, and outcome. The next turn retrieves the closest past reflections as a past experience block. The agent learns the workspace over time; the operator sees the whole memory at /settings/agent/memory.
Read-only tool calls in a turn fan out in parallel, up to eight at a time, and stream results in completion order. A turn with ten reads finishes in roughly the slowest call’s time. The management is real; it is also fast.
The human curates what matters
Meaning becomes data. Decisions, risks, commitments, intent — structured, persistent, ready for the agent to reason over. The human curates the semantic pill on the signals feed — this is a decision, this is a risk, this is an outcome — and the substrate keeps the shape.
The interface for the human is a curation surface: what matters, what changed, what needs a next step. Real value returns to the person entering the data.
The interface for the agent is the same substrate through the same catalogue of tools. Both surfaces work the same objects, at the same moment, with no stitching layer between them.
What the incumbents miss
The incumbents are racing to bolt headless agent APIs onto data models designed twenty years before agents existed. They have recognised that agents matter. They have yet to recognise what comes after.
Retrofitting agent behaviour onto a pre-agent schema inherits the shape of the underlying system: per-org permission drift, partial tool-surface coverage, per-entity engineering every time a new object type needs to reach the agent, a second observability pipeline for the AI layer, separate audit reasoning for service-account tool calls.
Starting agent-native inverts each of those costs. On the Actionary substrate, a new entity is agent-readable, agent-writeable, workflow-invocable, and audit-covered the moment the schema is registered — because the substrate treats every entity uniformly.
The takeaway
CMR names a category change. The human work of curating relationships and the agent work of acting on them become the same work, on the same data, through different interfaces.
Different shape, different centre of control, different competitive question — machine-readable value at the centre. The next-decade CEO picks the substrate that treats it that way from the first migration.
The next category has a different name for a reason.