What is an agent-built CRM?
Agent-built CRM, defined
People ask this as: what is an agent-built crm, build your own crm with a coding agent
An agent-built CRM is a CRM application whose source a coding agent composes against a framework's contracts, leaving reviewable code the operator owns rather than configuration inside a vendor's runtime. The agent is the builder at development time; the running application is ordinary deterministic software, and the agent is not its control plane. Accordo gives the agent the rails to build with — inspect, plan, scaffold, verify — and states the limits in the same breath: no measurement exists of how often an agent completes a build, nothing installs from npm, and the result runs locally without authentication.
Where this stops
Read this before the rest of the page. Every line below is a thing this does not do.
- Agent-built names who assembles the source at development time. It does not mean the model operates the CRM at runtime, approves its decisions or acts as its control plane.
- No measurement of agent build success exists. The benchmark protocol is published and has not been run, so no completion or reliability figure may be quoted (L-03).
- The built application is local-development-only: no authentication, tenancy or RBAC, and SQLite persistence (L-01, L-02).
- Nothing installs from npm. The agent scaffolds from a checkout of this repository, and the framework is vendored into the project (L-08).
- A Solution Plan validates against a real inspection and executes nothing. Planning is a checked file, not an automation.
- Code-generating and destructive MCP tools are dry-run unless an explicit apply flag is passed. The default answer to a write is a preview.
No authentication, tenancy or RBAC. The server is local-development-only. An actor header is an assertion, not an identity. Do not expose it to a network. Every claim and every limitation is on one page.
The definition, and what it is not
An agent-built CRM is a CRM application that a coding agent — Claude Code, Codex, Gemini CLI or similar — assembles as source code from a framework's contracts, under a human's review, in the human's repository. To build your own CRM with a coding agent is to state a business goal to the agent and receive checked-in modules, workflows and policies you can diff, test and keep. The defining property is where the work lands: in source the operator owns, not in a vendor's configuration store.
The term is easy to confuse with two things it is not. It is not an AI CRM — a product whose runtime features are model-driven — and it is not an autonomous salesperson: in an agent-built CRM the model's authority ends when the source is merged. The application that results is deterministic software whose commercial state changes pass through explicit services and workflows, whatever runtime AI its owner later chooses to add.
How Accordo supports the build
The agent needs to know what already exists before it writes anything, so one command reports the composed application — packages, capabilities, resources, actions, policies, providers — read from checked-in source, never from a live process (C-14). A Solution Plan is a checked-in file bound to that inspection's fingerprint, so a plan written against an application that has since moved reports itself stale rather than silently misleading the next session; nothing executes it (C-15).
Writing goes through the same declared surfaces a human would use: module manifests that generate migrations, services, REST resources, SDK methods and Admin screens (C-01), and package scaffolds for whole domains. The local MCP server exposes project context and narrow tools, and anything that generates code or destroys state is dry-run unless an explicit apply flag is passed (C-18) — the agent proposes, the diff decides.
What the rails do not include is a measurement. The framework publishes a build benchmark protocol and has not run it, so no rate of successful agent builds exists, and this page quotes none (L-03). What is checkable instead is narrower: the commands above exist, their contracts are tested, and the verification gate runs the whole suite on every push (C-20).
What the built application is, and where it runs
The output of an agent build here is a local application: Node 22, SQLite persistence, no authentication, tenancy or RBAC, so it runs on one developer's machine and must not be exposed to a network (L-01, L-02). It is a working system to develop against and reason about, not a system a team signs in to.
Ownership follows the same mechanics as any Accordo project: the framework arrives by scaffolding from a checkout, nothing installs from npm, and upgrading means merging — the reserved registry name is still an empty placeholder (L-08). The agent that built the application does not remain attached to it; what remains is source, tests and the evidence trail the framework wrote while the application ran.
The evidence this page rests on
Claims and limitations are printed from site/claims.json word for word. Job statuses come from docs/benchmarks/jobs.json; a job with no page of its own is listed with its status rather than linked.
Claims
- C-01 Write a module manifest; the agent turns it into a migration, a service, a REST resource, an SDK method and Admin screens — with no page code.
LimitGenerated CRUD only. The factory does not generate workflows or approvals for a custom object — that is still handwritten (JTBD-06, partially supported).
- C-14 One command tells an agent what an application actually is — packages, capabilities, resources, actions, policies, providers — read from checked-in source, in a single deterministic JSON report.
LimitSource-only and read-only. It never opens the database, contacts a provider, reads a secret, or reports runtime, CI or authorization state — and it lists those blind spots as machine-readable limitations in its own output.
- C-15 A Solution Plan is a checked-in file with a contract and a canonical fingerprint, validated against a real inspection — so a plan written against a composition that has since moved reports itself stale.
LimitA document contract, not a planner and not a runtime. Nothing executes a plan, and the validator refuses a plan that carries a command.
- C-18 The MCP server exposes project context and narrow write tools to a coding agent; anything that generates code or destroys state is dry-run unless you pass an explicit apply flag.
LimitStdio only, local only. There is no hosted or authenticated MCP endpoint, and the server inherits the local process's authority.
- C-20 The verification gate runs on every push — source checks and then the whole test suite — covering happy paths and the policy boundaries that matter: hostile input, transaction rollback, idempotency, concurrency and immutability among them.
LimitA test count measures effort, not correctness — read the adversarial-review categories in docs/QUALITY_GATES.md to see what is actually attacked. Real-browser tests are run manually and are not in CI.
Limitations
- L-01 No authentication, tenancy or RBAC. The server is local-development-only. An actor header is an assertion, not an identity. Do not expose it to a network.
- L-02 SQLite only. Persistence is Node's built-in SQLite adapter. PostgreSQL is on the Production Spine track and is not implemented.
- L-03 The build benchmark has not been run. The protocol is designed and published; no Successful Agent Build Rate exists yet. Any number you see quoted for this project is not ours.
- L-08 Ownership today means copying source, not installing a dependency. There is a project bootstrap and there is no published package, and the two are different facts. The repository's bootstrap command scaffolds a project that boots, reports `valid` from `app inspect` and exits 0 from `project doctor`, offline and with no install — run from a checkout of this repository. The package published under the reserved npm name is still an empty 0.0.1 placeholder, so the `npm create` route installs nothing until a human publishes it. Either way the framework is vendored into the project rather than depended on by version: you own the result outright, and upgrading means merging, not bumping.
Jobs it covers
- JTBD-AX-01 Discover installed packages, capabilities and policies — validated end to end
- JTBD-AX-02 Extend the CRM for a goal without patching the kernel — validated end to end
- JTBD-AX-03 Turn a business objective into a reviewable solution plan — partially supported
- JTBD-AX-04 Build the solution as checked-in, customer-owned source — partially supported
- JTBD-PK-05 Scaffold a new package from a template — validated end to end