Relationship intelligence should be a record, not a mailbox of interactions. Here is how to join every touch, document, and number onto one Contact ID, code it to a codebook, and read a whole relationship into a single cited brief.
In short: Build a relationship record by attaching every interaction — survey, document, meeting note, check-in — to one persistent Contact ID, coding the qualitative signal against a codebook so a score and its source sentence live together, and synthesizing the whole record into a single cited brief. Keep it first-party and reproducible rather than a fresh guess each run. In Sopact Sense relationship intelligence becomes a record you can trace, not a mailbox of interactions you re-read from memory.
A relationship without a record forgets what was said. The first move is to stop treating a stakeholder as a set of scattered threads — an email chain here, a meeting note there, a survey in a separate tool — and attach every interaction to the same persistent Contact ID. In Sopact Sense that ID is assigned at first contact and carried forward, so surveys, uploaded documents, meeting notes, and check-ins all land on one record instead of four disconnected places you have to reassemble by hand.
Attach every interaction for this stakeholder — surveys, documents, meeting notes, check-ins — to their single persistent Contact ID [ID]. List anything currently living in a separate thread or spreadsheet that needs to be joined to the record.
Once the interactions live on one record, the qualitative signal — what the stakeholder actually said — has to be coded consistently, or the record is just a longer pile of text. Map each open response and note to your codebook so the score and the exact sentence behind it stay together. That pairing is what makes the record defensible: every rating points back to the words that produced it. The codebook itself is worth building deliberately — see how to build a data dictionary.
Code the qualitative signal in this stakeholder's record [RECORD] against our codebook. For each theme, return the score and the exact source sentence behind it, so the number and its evidence stay together.
Expected output. A themed table for the stakeholder: each code with its score and the source sentence that justifies it, so a reviewer can trace every number to the record. Input: the coded interactions on the Contact ID plus your codebook. Output: a score-plus-evidence table per theme.
With the record joined and coded, read one stakeholder's entire history into a single relationship brief — the Intelligent Row view of that person or organization. The brief states current status, key needs or commitments with the source sentence, open flags, and what changed since the last touch. Everything is cited to the record; nothing is inferred.
Synthesize this stakeholder's full record [RECORD] into a one-page relationship brief: current status, key needs or commitments with the source sentence, open flags, and what changed since the last touch — everything cited to the record, nothing inferred.
Expected output. A one-page brief with four blocks — status, needs and commitments, open flags, and change-since-last-touch — each line carrying the source sentence it came from. Input: the coded record on the Contact ID. Output: a cited one-page relationship brief.
GRADE: green | status + change-since-last-touch | every line cited to the record; amber | needs/commitments | coded but not yet verified with the stakeholder; red | open flags | inferred rather than drawn from a source sentence
Green is a brief where status and what-changed are each backed by a source sentence on the record. Amber is a coded need or commitment that has not yet been confirmed with the stakeholder. Red is any flag the model inferred without a sentence behind it — those get removed or traced before the brief is used.
The record is only an asset if it can be trusted twice. Exclude sensitive fields from AI processing and run synthesis on anonymized IDs where the work requires it, and require every line of a brief to trace to a source sentence so the same run returns the same cited result rather than a fresh guess.
Re-run this synthesis excluding the sensitive fields [FIELD LIST] and using anonymized IDs. Confirm the output is reproducible from the record and flag any line that could not be traced to a source sentence.
A relationship without a record forgets what was said. The value is not any single interaction — it is the connected history on one ID. If you find yourself re-reading old threads to remember where a relationship stands, the record has not actually been built yet.
Keep score and sentence together. A theme score with no source sentence is an opinion; a source sentence with no code is unstructured text. The record earns its keep only when every number carries the words behind it.
Exclude sensitive fields and run on anonymized IDs. Where a record holds personal or protected information, keep those fields out of AI processing and synthesize on anonymized IDs, so the brief stays useful without exposing what should not be exposed.
Improve your synthesis accuracy with your own language. Point the Assistant at your program page or brief so it uses your framework and terms, not generic labels, when it codes and summarizes the record.
Read our program page [URL] and re-run the record synthesis using our own outcome and indicator language, so the brief speaks in our framework rather than generic terms.
Build a relationship record by attaching every interaction — survey, document, meeting note, check-in — to one persistent Contact ID for the stakeholder, instead of leaving them scattered across threads and spreadsheets. Map the qualitative signal to a codebook so a score and the source sentence behind it live together, then synthesize the whole record into a single one-page brief that cites everything to the record and infers nothing. In Sopact Sense the record is first-party and reproducible, so relationship intelligence is a durable asset rather than a mailbox of interactions you re-read from memory each time.
A CRM inbox stores interactions as separate threads — emails here, meeting notes there, a survey somewhere else — so understanding a relationship means re-reading and re-remembering every time. Relationship intelligence joins all of it onto one Contact ID and codes the qualitative signal against a codebook, so the current status, open commitments, and what changed since the last touch can be read from one record with the evidence attached. The record remembers what was said; an inbox only holds where it was said.
Keep a relationship record safe by excluding sensitive fields from AI processing and running synthesis on anonymized IDs where needed, and keep it reproducible by ensuring every line of a brief traces to a source sentence in the record rather than to an inference. Because Sopact Sense works over a first-party record, the same synthesis run twice returns the same cited result — so a relationship brief can be defended, not just generated.
ChatGPT, Claude, and Gemini are fine for a quick test — but not for an answer you'll put in front of a funder or board. When it has to hold up, run it in Sopact Sense.
Try it in Sopact →
