A CRM earns its value from being the place everybody agrees on. The moment there are two places, the value does not halve; it mostly disappears, because now every number needs a conversation about which system produced it.
AI projects create second sources of truth faster than almost anything else, and they do it with good intentions. A vector index needs customer context, so a nightly job copies accounts into it. An assistant needs conversation history, so it keeps its own. An agent cannot update a CRM field cleanly, so it writes a note instead and the structured data quietly stops being structured. None of these decisions feels like a data architecture decision at the time. Together they are one.
Decide system of record field by field
"The CRM is the source of truth" is not a decision, it is a slogan. The decision is per field, and it has to be written down before the integration is built.
A workable version looks like this:
| Fact | Owner | Everyone else |
|---|---|---|
| Account name, owner, lifecycle stage | CRM | Reads live |
| Contact email and phone | CRM | Reads live |
| Subscription plan and entitlements | Billing | CRM mirrors, labelled |
| Ticket status and history | Help desk | CRM links, does not copy |
| Conversation transcript | Help desk | AI index references by ID |
| AI-generated summary or sentiment | AI layer | Written back as a clearly labelled field |
The last row is the important one. An AI layer is allowed to own data. It just has to own data that nothing else claims. A summary, a suggested category, a confidence score, a detected intent: these are genuinely new facts and they belong to the system that produced them. A customer's email address is not a new fact, and the AI layer must never be the place anyone looks for it.
If two systems can both change the same field, you do not have an integration. You have a race, and the winner is whichever job ran last.
Reference, do not replicate
The default instinct when building a retrieval layer is to copy everything into it. Resist it in proportion to how fast the data changes.
A practical split:
- Index the slow, textual material. Knowledge base articles, policies, product documentation, closed conversation transcripts. These change on a schedule and are safe to embed.
- Fetch the volatile facts live. Order status, balance, plan, open tickets, anything the customer can change themselves. Call the API at answer time.
- Store identifiers, not values. The index holds
account_id, not the account's current plan. The agent resolves the ID when it needs the value.
This is slower per request and it is correct. A grounded assistant that tells a customer their subscription is active because that was true at 2am is not a retrieval bug, it is an architecture choice someone made without noticing.
Give the integration its own identity
Automations frequently run under a credential belonging to a person, often whoever set the integration up. It works immediately and it causes three problems: the audit trail attributes machine actions to a human, the permissions are far wider than the workflow needs, and everything breaks when that person changes role.
Give the integration a service account with its own credential, scoped to the specific objects and fields it touches. Then:
- Grant write access only to the fields it is allowed to own.
- Keep read access as narrow as the workflow tolerates.
- Rotate the credential on a schedule and store it in a secret manager, never in a workflow step.
- Make the account identifiable in the CRM's activity log so machine writes are distinguishable at a glance.
Marking machine-generated writes is worth doing even when it feels like overhead. The first time somebody asks why a field changed, the difference between "a person did this" and "the intake automation did this at 04:12 from ticket 8814" is the difference between a two-minute answer and an investigation.
Write back carefully
Writes are where an integration stops being a convenience and starts being a risk. Four properties make them safe:
- Idempotent. The same event arriving twice produces one outcome. Use the source event's ID as a deduplication key and store what you have already processed. Webhooks are redelivered as a matter of routine, not as a failure.
- Narrow. The integration updates named fields on named objects. It does not have permission to do anything else, so a bug cannot do anything else.
- Non-destructive by default. Append rather than overwrite where the field allows it. Never clear a populated field because the source returned empty: an empty source value usually means the lookup failed, not that the fact was deleted.
- Reversible. Record the previous value and the reason for the change somewhere queryable, so a bad run can be identified and undone without reconstructing it from memory.
Validate before writing, too. Normalise formats, reject values that fail a sanity check, and route anything ambiguous to an exception queue rather than guessing. An automation that writes Unknown into a thousand records has done more damage than one that wrote nothing and raised an alert.
Keep AI-generated fields labelled as AI-generated
When an assistant summarises a conversation, classifies an intent or proposes a next action, that output goes somewhere. The temptation is to drop it into the existing notes field, where it is indistinguishable from something a colleague wrote.
Give machine output its own fields, named so nobody has to ask:
ai_summarywith the model and timestamp attached.ai_suggested_categoryseparate from the human-setcategory.ai_confidence, so a downstream report can filter on it.- A flag recording whether a person reviewed and accepted it.
Separate fields mean a human correction is visible as a correction, reporting can exclude unreviewed machine output, and the whole thing can be removed if the model is replaced. Mixed into a free-text note, none of that is possible.
Do not let the assistant invent a status
A related failure: an assistant asked about a case with no clear status will often produce a reasonable-sounding one. If that answer is written back, the system has manufactured a fact. Any write derived from a generated answer should be traceable to a retrieved value, or it should not happen.
Sync direction, cadence and conflict
Most integration pain comes down to three undocumented choices. Document them.
Direction. One-way wherever you can get away with it. Two-way sync is a genuinely hard problem (it requires change detection, loop prevention and a conflict policy on both ends), and it is frequently adopted for convenience rather than need. Ask whether the second direction is actually required or whether a link would do.
Cadence. Event-driven where the platform supports webhooks, with a periodic reconciliation pass to catch what was missed. Webhooks are delivered at least once, sometimes zero times. A nightly sweep that compares counts and repairs gaps is cheap insurance and it is how you find out the webhook subscription expired.
Conflict. Decide in advance what happens when both sides changed since the last sync. Last-write-wins is a policy; so is source-of-record-wins; so is quarantine-and-ask. Having no policy is also a policy, and it is the one that produces the support ticket nobody can explain.
Signs you already have a second source of truth
Worth checking against the system you are running now:
- Two reports built from different systems give different totals for the same question.
- Someone maintains a spreadsheet to reconcile two platforms.
- The answer to "where do I look that up" depends on who you ask.
- A field exists in two systems and both are edited by people.
- The AI assistant has been wrong in a way the CRM was right about.
- Nobody can say when the AI layer's copy of a record was last refreshed.
Each of these is fixable, and the fix is almost always the same: name the owner of the field, make every other system read it, and delete the copy.
A short sequence that works
- List the facts the assistant needs, and for each one name the system that owns it.
- Split them into slow material that can be indexed and volatile values that must be fetched live.
- Create a service account scoped to exactly those reads and writes.
- Define the handful of fields the AI layer may write, all clearly labelled as machine output.
- Build one direction, event-driven, with a reconciliation pass.
- Instrument it (writes performed, conflicts hit, records quarantined), and review that weekly for the first month.
The discipline is unglamorous and it is what keeps the CRM worth having. An AI layer should make the system of record more useful, by reading from it accurately and adding genuinely new fields beside it. The moment it starts keeping its own version of the customer, you are maintaining two CRMs and trusting neither.
If you are connecting an assistant to a CRM or help desk, see how we scope integrations or book a strategy call to settle ownership before anything is wired together.