Connect by JBRH documentation

Every public page about Connect: what each capability does today, the end-to-end workflows, the technology behind them, and what to do when something fails. Each page states its status and the date it was last checked against the running system.

Status: Available What this means
Audience: both
Last verified: 2026-09-10
Product version: 6.3.2

Docs#

Page	What it covers
Phone and voice in Connect	How Connect answers and places calls: the two voice engines, what a line owns, and where every phone topic in this manual sits.
Email in Connect	The email channel end to end: the providers you can connect, what a mailbox owns, how a provider message becomes canonical, and where every other email page sits.
Prospecting in Connect	The prospecting section: the stages from a discovery brief to a first reply, the evidence rule underneath them, and where each page sits.
Relationships in Connect	The section map: Person, Identity and Company, the console that answers one relationship for both audiences, and where every other page here sits.
Sales in Connect	Opportunities, the pipeline and demos — and the line between a question Connect can answer from Knowledge and a commercial decision it must escalate.
Follow-ups in Connect	The section map: what a dated commitment is, the six channels one can sit on, which of them a drain executes, and where every other page here lives.
Support in Connect	The section map: what a support case is, how onboarding works, why the relationship carries on after the sale, and where website enquiries actually live.
WhatsApp in Connect	WhatsApp as a Connect channel: the two ways a number is connected to Meta, what Meta decides, and where every WhatsApp topic in this manual sits.
SMS in Connect	SMS in Connect is a foundation: inbound, dedupe, STOP and suppression work; outbound depends entirely on the provider, and the live carrier carries no SMS.
Connect Assistant	What the Connect Assistant is, the 66 tools behind it, how every write reaches a record, and the authority it deliberately does not have.
Memory in Connect	What Connect remembers about a business and its people: four tiers resolved narrowest-first, how each is written, and how a person reads or forgets any of it.
Knowledge in Connect	Where a grounded answer comes from: the sources a workspace supplies, the authority each one carries, and how a few passages reach a reply.
What Connect may do	The controls deciding what Connect may send, call or do on its own: four modes, four scopes, the approval queue, and the decision log.
Files and data in Connect	The two halves of Files and data: one file service shared by both audiences, and a grid over 13 record sheets that never writes to a table directly.
Account and access	How you get into Connect, what a session is, which workspace you land in, who may change what, and the switches an individual person owns.
Security and isolation	How one workspace is kept from another, what is recorded and reviewable, and what this section deliberately does not publish.
Connect by JBRH	What Connect by JBRH is, the five channels it works across, the records it keeps, and the controls that decide what it may do without asking.
Getting started with Connect	The shortest route from an empty workspace to Connect handling real work: the order to do things in, what each step proves, and where setups stall.
How-to guides	Task-shaped instructions for Connect: each guide is one job from first action to proof it worked, with the recovery when it did not.
Business use cases	The shapes of work Connect is put to, what each one needs configured first, and the limits that decide whether a given shape is possible at all.
Technology reference	How to read the technology reference: the ten questions every page answers, the five status words, and the rule that Connect's own use is always stated.
Protocol reference	The wire protocols and description formats Connect speaks, the exact version of each, and which ones Connect only explains rather than runs.
End-to-end workflows	How every end-to-end flow in this manual is documented: the twelve stages, what each promises, how to read the failure column, and the index of every flow.
Glossary	One canonical definition per term in Connect, and the rule that every other page links here instead of defining a word a second time.
Comparisons and concepts	The index of Connect's comparison pages: how it sits beside a CRM, a helpdesk or a call centre, and the internal distinctions people confuse.
Troubleshooting	The index of documented failures, plus how to read a page here: what each one promises, the three questions to answer first, and what is never printed.

Phone#

Page	What it covers
Your business number in Connect	What a phone number becomes once a workspace claims it: a channel_routes line that carries the provider, the permissions, the hours and the routing.
Configuring a phone line	The ten facts that make up a phone line, what each one refuses when it is set wrongly, and the order to decide them in.
How a call reaches your workspace	How a dialled number becomes a workspace, why every handler enters that workspace before reading a setting, and what an unclaimed number does.
Carrier callback verification	Why every carrier callback is signature-checked inside the owning workspace, what a replayed webhook looks like, and the index that stops one.
Answering inbound calls	From ring to greeting to first reply: the gates a caller passes, what they hear at each refusal, and what is written down while they talk.
Placing outbound calls	The five gates an outbound call passes before a number is dialled, what each refusal means, and how a call-back gets placed at all.
Business hours and the closed line	How opening hours are set on a line, what a caller hears outside them, and why the closed-line message never speaks the hours aloud.
Switching the line off	What switching a phone line off does to a caller, to the call record and to work already scheduled on that line — and why it is not silence.
The call record	Every field on a call: ring and answer times, provider status, cost, participants, quality, and why outcome and disposition are separate columns.
Call transcripts	How a call transcript is assembled turn by turn, what the latency beside a reply actually measures, and the three things a transcript is not.
Call summaries	When a call summary is written, the two conditions under which Connect refuses to write one, and what a summary is allowed to contain.
Call outcomes and dispositions	The engine's outcome and a person's disposition are two columns answering two questions. What each one says, and how to use them together.
Who ended the call	The six values of hangup_by, why every non-caller ending once read as 'agent', and how to tell an ended call from a dropped one.
Calls that were never a conversation	no_answer, not_reached and silent failure are three different nothings. What each one means, how to tell them apart, and why none creates a lead.
The realtime voice engine	The speech-to-speech calling path: how a workspace turns it on, what the worker is given for each call, and what it is never allowed to know.
The carrier turn-based engine	The carrier webhook path — gather, reply, redirect — when it is the right engine for a line, and the three things it cannot do.
The voice worker	The process that holds a realtime call: how it starts, what it heartbeats, how a deploy drains it, and what a caller gets when none is running.
Capacity and admission control	How admission decides a call can be taken: load per core, the 0.85 threshold, why a silent worker reads as free, and what saturation does to a caller.
The greeting	How the first sentence of a call is chosen, why it is synthesised while the phone is still ringing, and what happens when it cannot be spoken.
Greeting warm-up	How Connect has the first sentence of a call already synthesised before the phone is picked up, and the quota refusal that once cost every restart its warm greeting.
Barge-in	Speaking over the voice on a live call: what stops it, the two-second rule that decides an interruption was ignored, and why the greeting is protected.
Turn detection and end of speech	Deciding that the caller has finished speaking: the model's own detection, the host semantic path with dynamic endpointing, and how to choose between them.
Silence and check-ins	What Connect does when nobody is speaking: how presence is tracked, why nothing is said over a caller, and what a silent stretch leaves on the record.
Abandoned calls	Calls the caller walked away from: how the hang-up watcher recognises real abandonment, what it records, and why no closing line is spoken.
Reply latency on a call	How long a caller waits for a reply: what the clock measures, where the floor comes from, and how to tell a slow reply from a slow model.
The response watchdog	The timer that asks a stalled model to answer: why its default is 5.5 seconds, what disarms it, and how a nudge can cancel the very reply it was waiting for.
Multilingual calling	Calls held in more than one language: how the opening choice is made, what may change part-way through, and what a mixed sentence does.
Detecting the caller's language	What counts as proof a caller has changed language: four tiers with four different bars, the transcript artefacts that never count, and what pinning overrides.
Remembering a caller's language	A caller's remembered speaking preference: where it is held, why Connect speaks it from the first reply, what overrides it, and what it costs in the brief.
Regional speaking style	The regional speaking-style layer: the prompt directions it adds, the things it cannot touch, and why a rendered cadence rule was removed rather than kept.
Light code-mixing and slang	Hinglish and light slang on a call: when a mixed sentence counts as evidence and when it does not, and what asking a model for a register achieves.
Identifying the caller	Turning the number that rang into a person: the phone key, the rule when two records share a number, and what happens when nobody gives a name.
Names heard on a call	What happens to a name spoken on a call: the protected markers, why a form of address never becomes one, and every door it must pass on the way in and out.
A returning caller	The second time somebody rings: what Connect has already, how little of it reaches the conversation, and why continuity is not the same as recital.
The call brief	Everything assembled before a call starts: persona, purpose, contact facts, knowledge, rules and guidance — each with a character budget, and why the budgets exist.
Voice profiles	Named bundles of voice settings: where one can be attached, the six-step resolution order that decides which wins, and what is recorded on the call.
Human voice profiles	One choice that yields a whole person: 86 parameters across identity, speech, imperfections and psychology, and the ones marked unsupported rather than faked.
The Voice Lab	The screen where a line's voice is tuned: engine settings that take effect exactly, steering text the model interprets, drafts and test calls.
Call quality review	What a finished call is scored on: deterministic findings with the setting each one points at, the model's opinion kept separate, and limits that do not lower the score.
What a setting cannot change	Findings the call review counts but does not score, why they come with no control to turn, and the two behaviours proven unreachable by prompting.
Connect's own voice	Why the words a caller hears are synthesised by Connect rather than the carrier, how a sentence becomes a cached MP3, and the rule that forbids silence.
Telling the voice how to speak	The style block and the behaviour block: which settings become session parameters, which become instructions a model may only approximate, and which are neither.
Steering a live call	The panel a colleague uses to steer a call in progress: why guidance never reaches the caller, and why pause, take over and release are read back out of the log.
Transfer and escalation	What an escalation phrase queues on a live call, why the transfer capability is asked of the provider rather than assumed, and what the live carrier does not carry.
Calling from the browser	The browser line: a per-person SIP endpoint, why every state the dialler shows comes from a SIP event, and how a browser call actually makes a phone ring.
Follow-ups from a call	How a spoken commitment on a call becomes a dated follow-up: the words that parse into a time, the channel it lands on, and the default when nothing parses.
Promises made on a call	The rule that refuses a follow-up time the caller never said, what counts as agreeing to one, when a read-back is asked, and the finding for an empty promise.
Executing phone follow-ups	The drain that places a due call-back, the gates each one passes, the retry when no voice worker is ready, and the point at which a late follow-up is abandoned.
Facts learned on a call	What a phone call leaves behind in Memory, which extracted facts are refused outright, and how something heard on a call reaches a conversation on another channel.
Leads captured from a call	When a phone call creates a Person and a lead, the two call endings that deliberately create nothing, and the key the record carries from the very first ring.
Phone line health	The four things line health reports about a phone line, what each one means for somebody ringing the number, and why none of them has to be cleared by hand.
What a call costs	Why a voice call is metered by modality rather than by a total token count, the reporting field that never existed, and what a call reporting no tokens is charged.
The budget that stops a call	The budget question asked before an outbound call and before answering an inbound one, what a refused caller hears, and how the quota breaker differs from it.
Stuck calls and the sweep	Call rows left active by a worker that died or a browser call with no worker behind it, the sweep that closes them against the provider cap, and what it charges.
Consent on calls	Where consent for a phone call is decided, the single outbound path every call passes through, and why a block recorded elsewhere already applies to the phone.
Session limits and long calls	The model's session cap, the context window, the provider cap and the product's own thirty-minute ceiling — which one ends a long call, and what a caller notices.
Phone for the Owner and for a customer	What the phone channel does identically for the operator and for a customer workspace, what a plan changes, and the small set of things that stay operator-only.

Workflows#

Page	What it covers
Inbound phone call, end to end	A call arriving on a Connect number, stage by stage: what the caller hears, what is written, which provider acts, and what fails where.
Outbound phone call, end to end	Placing a call: the reason it exists, the gates it passes, the dial itself, and what is written whether or not anybody answers.
A promised call-back, end to end	A call-back promised out loud becomes a dated commitment and then a ring: how the time is read, when it is refused, and when it is too late to place.
Connecting a phone line, end to end	Connecting a number to Connect: the line record, the carrier link, and the four verifications that separate a configured line from an answering one.
Turning on the realtime engine, end to end	Switching a workspace to the speech-to-speech engine: the trunk, the dispatch rule, the worker and the console steps that have no API at all.
From a call to a customer relationship	What survives a phone call: the person, the company, the timeline entry and the next action, and the rules that stop each of them being invented.
Escalating a call to a person	When a caller asks for a person: what is queued, what the caller hears, what a colleague can do on the live call, and what a completed transfer still depends on.
Making a call from the browser	A person dialling from the browser: the SIP registration, the invite that does not dial the number in it, the bridge, and what is recorded as human-owned.
Tuning the voice, end to end	Changing how the voice sounds and behaves, then proving the change: the two kinds of control, the test call, the review, and the findings no setting can fix.
Recovering a failed call	Every way a call can fail on this path and the recovery for each, in the order the failures are detected — from admission control to a late provider webhook.
Inbound email, end to end	Every stage between a message landing at the provider and Connect acting on it: fetch, bridge, thread, triage, and where mail can be lost.
Drafting and approving a reply, end to end	From an arriving message to a sent reply, with the autonomy gate in the middle: what is drafted, what is held, who releases it, what proves it went.
Connecting Gmail, end to end	Connecting a Google mailbox from the consent screen to the first synced thread, with the evidence that proves each step actually happened.
Connecting an IMAP mailbox, end to end	Connecting a plain IMAP and SMTP mailbox: what you supply, the two separate proofs that must pass, and what a half-working connection looks like.
Repairing a broken mailbox, end to end	Detecting that a mailbox has stopped working, finding which half broke, reconnecting without creating a second row, and proving the repair held.
An email follow-up, end to end	A dated commitment becoming a sent email: where the follow-up came from, which gates it passes, and why a retry cannot send it twice.
An outreach sequence, end to end	Cold outreach from first contact to the reply that stops it, with every compliance gate named and the point where a stranger becomes a conversation.
An unsubscribe request, end to end	What happens between somebody asking to be left alone and the record that proves it: the suppression, its scope, and the one entry nobody clears casually.
Hitting the daily allowance, end to end	What Connect does when the day's allowance is spent: what is held, what is refused, why the read cursor stays where it is, and how work resumes.
From an email to an opportunity	The reply that turns into a deal: which records change, in what order, and what keeps the pipeline honest about where the evidence came from.
Discovering prospects, end to end	One discovery run followed from the brief to a qualified list: every stage, every gate that can stop it, and what exists afterwards.
Researching one prospect, end to end	One candidate followed through research: what is read, how a claim earns its place on the record, and what happens when nothing can be proved.
First outreach to a prospect, end to end	The first message to a prospect, followed from readiness through the compliance check, the draft, approval and the send that only counts with provider evidence.
Handling a prospect's reply, end to end	What happens between a prospect's reply landing and the record it changes: classification, the stop rules, and when a relationship is created.
Importing a prospect list, end to end	An import followed from the file to usable prospects: what each stage does to a row, what is merged, what is refused, and what the summary is for.
From first contact to a person record	A stranger writes or rings on any channel and becomes a canonical person: every stage, what changes, what can fail, and what happens on the second channel.
Merging duplicate people, end to end	From a duplicate proposal to one merged record: every stage, the human decision in the middle, and how to verify the result afterwards.
From prospect to client, end to end	One relationship followed from a discovered name to a paying client, naming every record that is created, changed or left behind on the way.
From client to support, end to end	What carries over when a deal is won: onboarding, the first support case, and the continuity that depends on one person record rather than two.
Continuing one conversation on another channel	What happens when someone who emailed last week rings instead: how the same person is recognised, and exactly which context follows them.
Creating an opportunity, end to end	From a sentence in a conversation to a deal on the board with its first commitment: every stage, what changes, and what can fail on the way.
Moving a deal from stage to stage, end to end	Every stage change on an opportunity: what is checked before it, what is written after it, and the side effects a move sets off downstream.
Answering a commercial question, end to end	A customer asks what it costs: the grounded answer, the refusal, the escalation, the human decision, and how the same question stops recurring.
Closing a deal, end to end	What changes when an opportunity is marked won or lost: the stage rules, the stored value, the follow-ups that stop, and what picks the person up next.
Creating a follow-up, end to end	From a promise made out loud to a scheduled row: the guard on the time, the channel decision, the duplicate test, and what each stage records.
Executing a follow-up, end to end	From due to placed, held or refused: the drain's rate, every gate in order, the outcome written back, and the lateness rule that ends it.
Approving a follow-up, end to end	How a follow-up Connect may not execute on its own reaches a person, what the approver is allowed to change, and what runs after the yes.
A support case, end to end	A customer problem from the message that raises it to the resolution and the memory it leaves: every stage, what changes, and what can fail at each.
Onboarding, end to end	Onboarding from the won deal to steady state: the stages, who does what between them, and the failures that leave a new customer waiting.
A website enquiry, end to end	A public-site enquiry from the submitted form to an answered person, and the stage where having no workspace decides everything that follows.
An inbound WhatsApp message, end to end	One inbound WhatsApp message followed the whole way: Meta's signed webhook, the stored record, the draft, the autonomy decision and the timeline entry.
A WhatsApp follow-up, end to end	A scheduled WhatsApp follow-up from due to sent: the composition, the autonomy and consent checks, the window, and the template fallback when Meta refuses.
Connecting WhatsApp, end to end	Connecting WhatsApp from a Meta credential set to a first verified inbound message, the QR alternative, and the checkpoint that proves each half of the chain.
A WhatsApp opt-out, end to end	A WhatsApp opt-out followed end to end: the STOP word, the three records it writes, what changes for every pending message, and the START that reverses it.
An inbound SMS, end to end	An inbound text message followed from the provider webhook to the person it belongs to and the decision about answering it, with what can fail at each stage.
An SMS STOP, end to end	A stop request followed from the word in the message to the suppression, the audit entry and the confirmation, including what is deliberately skipped.
Preparing for DLT, end to end	Preparing for DLT in India: what a business gathers, in what order the three registrations must be obtained, and what Connect stores once they are granted.
Asking the Assistant a question, end to end	A question typed into the Assistant, followed all the way to a grounded answer: what runs at each stage, what it costs, and where an answer loses its citations.
Asking the Assistant to do something, end to end	From an instruction to an audited change: how a writing tool becomes a proposal, what the confirmation buys you, and where autonomy re-enters the path.
Working on a file with the Assistant, end to end	Attaching a file to the Assistant and working on it: validation, extraction, the answer, the new version, and where the file ends up linked.
Correcting Connect from a conversation, end to end	From a wrong answer to changed behaviour: how a correction typed in conversation becomes a memory at a tier, and what proves it actually took effect.
Undoing an action, end to end	Undoing an Assistant action: the three outcomes — reversed, compensated, or recorded only — and how to tell which one your action will get.
Correcting what Connect knows, end to end	From a reply that was wrong to a corrected memory to changed behaviour: every stage, what changes at each, and the three places a correction fails to stick.
A fact learned on a call, end to end	Following one spoken fact from the moment it is said, through the checks that decide whether to believe it, to the email where it is used a week later.
Blocking a contact, end to end	One tag on one memory row, and what it stops across email, WhatsApp, SMS and voice — including the browser line a colleague dials from.
Reviewing everything Connect knows about a person	The audit anyone can run on one person's record: the four tiers, the tags, the identities behind them, and the decisions that follow from what you find.
Adding a Knowledge source, end to end	From choosing a file to a passage that answers a question: every stage of adding a Knowledge source, with the status the record carries at each.
Producing a grounded answer, end to end	A customer question turned into a defensible reply: scopes, retrieval, the sufficiency gate, drafting under labelled context, and the citations kept.
Resolving conflicting Knowledge, end to end	From a contradiction being detected to a source that answers again: what is compared, what is refused, and the decision only a person can take.
Auditing what an answer was based on	Taking one sentence in a sent reply and following it back to the passage, the authority and the person who allowed it to be said.
Approving a held action, end to end	A held action from the moment it reaches the queue to the provider's acknowledgement: who may decide, what an edit changes, and what the log keeps.
Changing what Connect may do, end to end	Changing an autonomy rule end to end: what takes effect at once, what the change cannot reach backwards, and where the change itself is recorded.
Working the Needs You queue, end to end	One full pass through Needs You: how the list is ordered, what each kind of item wants from you, and what an empty queue does and does not prove.
Escalating to a person, end to end	What happens when Connect decides it should not answer: how the refusal becomes a person's decision, and how that decision gets into future work.
Stopping Connect, end to end	The runtime switch end to end: what stops the moment you use it, what was already handed to a provider, and what is waiting when you switch back on.
Uploading a file and answering from it, end to end	The whole path from dropping a file into Connect to reading an answer grounded in it: validation, safe parsing, extraction, grounding and the citation.
Creating a document, end to end	From asking for a document to a produced file sitting on the right record: what is resolved, what is proposed, what is written, and what is deliberately left blank.
Changing a document, end to end	Changing a stored document from end to end: which version is read, what the proposal shows, what the new version records, and what the old one keeps.
Editing many records at once, end to end	Selecting many rows in the Data grid and changing them together: how a selection becomes one service call per record, and what a partial result means.
Importing records, end to end	Bringing records in from a spreadsheet: how a file becomes validated rows, how duplicates are matched, and what happens to rows that do not qualify.
Signing in for the first time, end to end	From the Google consent screen to the first working screen: what a session is, how one workspace is resolved, and what a first sign-in does not do.
Setting up a workspace, end to end	Taking a workspace from empty to working: the business profile, the channels, what Connect is allowed to say, and what it may do unsupervised.
Adding a colleague, end to end	How a second person gets into a workspace: membership, their own Google sign-in, the role that gates configuration, and what is recorded per person.
Changing plan, end to end	What a plan change alters the moment it lands, what it deliberately leaves alone, and why a lowered ceiling never removes anything you already have.
A lapsed plan and its recovery, end to end	The whole arc of a lapse: what stopped, what queued rather than failed, and the order in which work resumes once the workspace is live again.
Proving a workspace is isolated, end to end	A layer-by-layer check that one workspace cannot reach another's records, what each of the three layers catches, and what each of them cannot see.
Rotating a provider credential, end to end	Replacing a provider credential in a workspace: what happens on save, how to verify a value you can never read back, and what becomes of work in flight.
Responding to a suspected access problem, end to end	What to do when access to a workspace looks wrong: contain first, establish scope from evidence, then rotate — in that order, with what each step proves.
Google sign-in, end to end	From the Google consent screen to a working session: what Google proves, what Connect binds it to, and the mismatch it refuses rather than resolves.
Establishing a session, end to end	What a session actually is in Connect: what the server keeps, what the browser holds, what it resolves to, and what can be ended from which side.
Binding a Google identity to a person, end to end	How a Google account becomes a person in Connect: binding on the first non-empty subject, adopting a row that predates them, and refusing a later mismatch.
Resolving which workspace a request belongs to	How a request is tied to exactly one workspace before any handler runs, and the three independent places that resolution is enforced afterwards.
Routing a request for the Owner or a customer	One implementation, two doors: how a request is rewritten for a customer, checked against an allowlist, and refused in the two ways that both fail closed.
Granting a permission, end to end	Granting or removing a permission in a workspace: who may do it, when the change takes effect, what it does not widen, and the record it leaves.
Turning Connect on or off at runtime	What the runtime switch actually stops, what finishes anyway, what happens to work that was scheduled, and what the people on the other end experience.
Entitlement and runtime choice, end to end	Two separate gates decide whether Connect acts: what the plan permits, and what a person has switched on. Both must agree, and they fail differently.
A plan lapsing, end to end	What a lapsed plan actually stops: which work is refused, which is held, why the mail cursor stays where it is, and what returns on settlement.
Signing out and replacing a session	The two ways a session ends on one browser — signing out, and signing in as somebody else — and why neither of them touches your other devices.
Reviewing account security, end to end	A working review of one workspace's access: the sessions, the provider grants, the stored credentials and the audit trail, with the question to ask of each.
Assigning a mailbox role, end to end	Giving a mailbox a role, from the click to the first message it re-routes: what is stored, what routing changes, and which conversations are deliberately untouched.
Repairing a workspace with no primary mailbox	A workspace whose primary mailbox is missing: how the gap shows itself, the two repairs, and why one of them cannot run from a browser request at all.
Catching up after a Gmail history gap	When Gmail can no longer serve the history a mailbox was reading from: what a gap is, what Connect re-fetches instead, and why order and duplicates are handled first.
Advancing an IMAP cursor safely	The rule that decides when an IMAP read position may move: what must be recorded first, what refusal holds it, and how advancing early loses mail for good.
Ingesting a burst of mail, end to end	Hundreds of messages arriving at once: how they are taken in, the order they are processed, what the allowance holds back, and why no wave of replies follows.
Creating a conversation thread, end to end	From one arriving message to a conversation with a person and a company attached: what is matched, what is created, and what is decided once and kept.
Assigning priority to a thread, end to end	How a conversation gets its priority, what happens when a person overrides it, and why that correction changes what Connect works on rather than how a list is sorted.
Regenerating a draft, end to end	Asking Connect to write a reply again: what is thrown away, what survives untouched, what the second attempt is given that the first was not, and when to stop.
Sending with provider evidence, end to end	Every state a message passes through between the decision to send and the provider's acknowledgement, including the third state that is neither sent nor failed.
What Connect changes in your Gmail after a reply	The step that reaches back into Gmail after a reply: what it writes, why it runs last, why its failure is allowed to pass, and which state flows which way.
Applying a suppression, end to end	What happens when an address or a person is suppressed: where the entry is recorded, which gate reads it, what refuses afterwards, and who is allowed to clear it.
Handling a spam complaint, end to end	A spam complaint from the moment it arrives: how the recipient is identified, what is suppressed, and what it should change about the way a workspace sends.
Handling a bounce, end to end	A bounced message from the notification to the record: how permanent and temporary failures are told apart, what changes on the address, and what is never retried.
Capturing evidence for a prospect, end to end	How one fact about a business travels from a public source to a stored piece of evidence to the claim it supports — and what stops it on the way.
Qualifying a prospect, end to end	How evidence gathered about an organisation becomes a score, how the score becomes a decision, and what happens when a person disagrees with it.
Finding a contact address, end to end	How Connect finds an address to write to, what it records about where the address came from, and why it will not construct one from a naming pattern.
Keeping a good prospect you cannot email	An organisation fits your criteria and publishes no address. What stays on the record, what Connect proposes instead, and the four ways it can become reachable later.
Running deep research, end to end	When a second, deeper research pass is run on one prospect, what decides that it is worth paying for, what it produces, and where the output is attached.
The readiness check before outreach	Every gate an outreach message passes before it leaves, in the order they are evaluated, and what a refusal at each one looks like from the screen.
Classifying a prospect's reply, end to end	What Connect does with an answer to cold outreach: the classes it sorts replies into, what each one stops or starts, and which ones a person must confirm.
Deciding whether two records are one person	From the signals that suggest two records are one person to the human decision and the merge itself, with what survives on both sides.
Moving a relationship through its lifecycle	Every lifecycle stage change: what triggers one, how the requested word is normalised, what the move records, and the things it deliberately leaves alone.
Assembling a Customer 360, end to end	Every store a Customer 360 reads to build one person's whole history, and why the cost of assembling it is counted in database statements.
Building the timeline, end to end	How a person's timeline is put together from the records that own each event, why it is ordered by when things happened, and what it leaves out on purpose.
A commercial decision reaching a person	What happens when a customer asks a price, a warranty or a deadline that Knowledge does not support: the refusal, the escalation, the human decision and the reply.
Handling a demo request, end to end	From a customer asking to see the product to a dated commitment somebody will actually keep: the record, the confirmation, the reminder and the outcome.
Handing a won deal to onboarding	What happens when an opportunity is won: which records carry over untouched, what is newly created, and the two mistakes that split a customer in half.
Configuring a channel, end to end	The shape every channel setup shares in Connect — identity, credentials, routing, rules, verification — and the specific places email, WhatsApp, phone and SMS differ.
Verifying a channel actually works	The one test that proves each channel is really working, what each test does not prove, and why a saved setting and a green screen are not evidence.
Continuing on a different channel	Continuing a conversation on a different channel: what history carries over, what has to be re-established, and the identity check that decides both.
A channel provider going down	What happens when a channel's provider stops answering: how the failure is detected, what stops attempting, what carries on regardless, and how recovery works.
A do-not-contact reaching every channel	One do-not-contact directive that reaches email, WhatsApp, SMS, phone and prospect outreach: where it is stored, why it holds, and what the audit trail shows.
Checking the Assistant's screen context	The Assistant is told which screen and record you are on. That claim is checked against the database before it is trusted, and dropped when it does not hold.
Executing one Assistant tool call, end to end	One Assistant tool call from argument to audit entry: what validates the arguments, which service does the work, the gates it passes, and what is recorded.
Writing a memory, end to end	How something worth remembering becomes a stored memory: the trigger, the tier it lands on, what the row carries, and the first reply that changes because of it.
Superseding a memory, end to end	Replacing something Connect believes without losing the record of what it used to believe: the new version, the kept history, and how each option reads later.
Ingesting a Knowledge source, end to end	What happens between adding a document and an answer being grounded in it: reading the file, refusing dangerous ones, extraction, and when it becomes usable.
Retrieving Knowledge for one reply	How much of your Knowledge actually reaches one answer: how the question is formed, what the budget allows, how material is chosen, and how to see the choice.
Producing a new version of a file	Changing a file produces a new version rather than overwriting one: what each version carries, how it links back to a record, and what the chain proves later.
Editing a record in the grid, end to end	One cell, changed: what the grid sends, which service decides, what comes back into the row, and the audit entry that survives the browser tab.
Metering usage, end to end	How Connect counts what a workspace uses: which dimensions exist, when each is reserved or merely tracked, and what the daily ledger is actually for.
Enforcing an allowance, end to end	The moment a daily allowance runs out: how the approach is checked, what the refusal says, what is held rather than lost, and how the work resumes.
The AI budget guard, end to end	The AI budget guard on the voice path: when it is asked, what it refuses, what a caller hears instead of silence, and how a call gets through again.
A provider quota breaker opening and closing	What a provider breaker does when a model account starts refusing: which work is skipped, which is still attempted anyway, and how the breaker closes.
Verifying a customer payment, end to end	How a customer payment is verified and a plan activated: deterministic evidence, a fail-closed match, and why this flow sits outside every workspace.
Creating a customer workspace, end to end	From a first Google sign-in to a workspace that can actually receive mail: what is created, what is not, and the three things still missing afterwards.
Removing a workspace, end to end	What removing a workspace actually does: how access ends, which records stay outside it by design, and which parts of it can never be undone.
An AI client calling a Connect MCP tool	How an AI client discovers a Connect workspace tool, authenticates with an integration key, and has the call scoped, gated and recorded like any other action.
An AI client searching the public documentation	The unauthenticated MCP path: which documentation tools any AI client may call without a key, what they return, and the limits that make them safe to publish.
An agent discovering Connect	How another agent finds Connect: fetching the Agent Card from its well-known URL, reading the published skills, and sending a message to one of them.
A developer calling the public API	A developer calling Connect over HTTP: how a key is issued and scoped, what one request looks like, how errors are shaped, and what a rate limit means.
Delivering an outbound webhook	The outbound webhook interface Connect publishes: the signed envelope, at-least-once delivery, the retry and pause rules — and why nothing is being delivered yet.
Publishing a documentation change	How a documentation change reaches the public site: one source, the gate, generated HTML and Markdown, the manifests, the sitemaps, and IndexNow last of all.
Verifying published documentation	Every check run before and after a documentation change ships: the gate, the link graph, structured data, the built tree, and the fetch-as-a-crawler probe.
A search crawler fetching a page	What a search crawler receives from this site, what it does not, how policy differs for search, user fetches and training, and how a bot proves who it claims to be.
An AI search engine citing a page	The chain from crawl to citation to referral: what has to be true at each step, which steps can actually be measured from this side, and which cannot.
Submitting changed URLs to IndexNow	Submitting changed URLs to IndexNow: how the changed set is derived, the three rules the tool enforces, the response codes, and why submission runs last.
First response to a new contact	How Connect decides whether to answer a new contact immediately, draft and wait, or refuse — and what the person on the other end experiences while that is decided.
Handling a request Connect cannot fulfil	What happens when somebody asks for something Connect must not answer: how it is recognised, how it is refused, who it reaches, and what the customer is told.
Escalating a complaint, end to end	How a complaint is recognised on any channel, who it reaches, what Connect commits to on the business's behalf, and what it deliberately refuses to promise.
Communicating during an interruption	What Connect says to customers during an interruption, what it keeps internal, who is told first, and why a cause and a restoration time are held back.
Answering a customer's data request	What Connect can produce when somebody asks for their data: which records, in what format, from where — and the limits, including what sits outside a workspace by design.
Proving a change did not break anything	Proving a change did not break anything: the verification ladder, which rung proves what, and the two audiences every screen change has to be checked as.
Reviewing calls as a routine	A weekly pass over the call record: which fields to read first, what each pattern points at, and which findings a setting can fix rather than the model deciding.
Reviewing mailbox health as a routine	A routine check of every mailbox: why connected is not health, the states worth watching, the pattern that hides a mailbox entirely, and the action for each.
Changing what the agent is told	Changing the words Connect is given: the six layers a prompt lives in, what extra characters cost on a live call, how to measure it and how to undo it.
Changing the model, end to end	Moving Connect to a different model: what to check first, what changes on the wire during the switch, and which numbers prove afterwards that it was worth doing.
Changing a provider, end to end	Swapping the carrier, the mail provider or the messaging provider underneath Connect: which layer changes, what has to be re-proved, and what may never be assumed.
Handling more volume, end to end	What binds first when volume rises — worker capacity, plan allowance, model quota, query cost — and the order in which to change them without guessing.
Reviewing an incident, end to end	After something goes wrong: which records to open and in what order, the questions that decide whether it is fixed, and what belongs in the write-up.

Troubleshooting#

Page	What it covers
No voice worker is available	Calls are refused or reach nothing because no voice worker has checked in: what the caller meets, why a screen once said ready anyway, and the two ways it clears.
The call connected and nobody spoke	The call connected and nothing was said: the greeting failure that used to read as caller abandonment, how it is recorded now, and what to check.
The carrier callback was refused	The carrier's callback was refused before the call was answered: what a refusal before pickup looks like on both logs, and the workspace-scope trap that causes most of them.
The call never rang	An outbound call recorded as never reached: how it differs from nobody answering, which of the dial, the dispatch or the worker failed, and what to do about each.
The voice model refused the session	The voice model would not start or dropped the session: the three close codes in plain language, the settings that cause each, and the retry and fallback.
Every line is busy	Calls are refused because every voice worker is over its load threshold: what the caller meets, how capacity is actually computed, and what to change.
A caller reached the closed-line message	A caller heard the closed-line message instead of the voice: why that is the line working, what the message says and does not say, and how to change it.
The call ended early	The call ended before the conversation did: how to tell a product ceiling, a session limit, a silence watcher and a carrier hang-up apart from each other.
The voice answered in the wrong language	The voice answered in a language the caller did not use: which language a call opens in, what counts as evidence for a switch, and the transcript that looks wrong and is not.
The voice talked over the caller	The voice kept talking over the caller, or stopped when nobody interrupted: the interruption thresholds, false-interruption resume, and why the host path leaves it off.
The greeting took seconds to arrive	Why a caller hears a pause before the first sentence: a cold worker process, a refused warm-up, or greeting wording that no longer matches the cache.
The call promised a call-back that never happened	A caller was promised a call-back and no follow-up exists: the time-mismatch refusal, the unbooked-promise finding, and where the evidence is.
The same call-back was booked twice	Two follow-ups for one promise: how a repeated commitment, a second call or a split person record each produce a double booking, and how to clear one.
A call cost more than expected	Why a voice minute costs more than a text minute: audio token rates, context re-billed every turn, restarts, swept calls and calls that report no tokens.
Nobody can reach the number	Nobody can reach your business number: the checklist in order — claim, trunk, routing, worker, hours, switch — and what each failure leaves on the record.
The mailbox disconnected	A mailbox has stopped authenticating: the causes in order of likelihood, what is still safe while it is down, and the path back to working.
Reconnect required	Why a stored grant stops working, what running the consent again restores, and the four things it deliberately does not put right.
Mail is in the provider but not in Connect	A message is visible at Gmail or on the mail server and absent from Conversations. Four checks, in the order that finds the cause fastest.
The reply would not send	A reply was refused by the provider or never left: how to read the category of failure, which ones are worth retrying, and what to do about each.
The send result is uncertain	A reply whose outcome the provider never confirmed: what that state means, why nothing is re-sent on a guess, and the evidence that settles it.
The draft is still waiting	A written reply that has not gone out: the four holds that cause it, the screen that reveals each one, and what the customer is experiencing meanwhile.
The recipient is suppressed	Connect refused to write to an address: how to find out why, who is allowed to clear the entry, and the one kind nobody should clear casually.
The same conversation appears twice	One conversation showing as two: why mail threading splits, what Connect can and cannot merge, and how the person's timeline restores the whole story.
Images in an email do not load	Pictures in a message are missing or broken: what the image proxy does, why it exists, and which of the five causes you can actually do something about.
The email renders badly	A message that renders as plain, broken or oddly laid out: what the sanitiser takes out, why it is aggressive, and how to see the original safely.
The reply went from the wrong address	Why a reply left from a mailbox you did not expect: how the sending address is chosen, why a thread keeps it, and what to do about a message already gone.
Gmail was not updated	The reply went out but Gmail still shows the thread unread and unlabelled: what write-back is, why its failure never blocks a send, and how to retry it.
Discovery returned nothing	Discovery finished and the list is empty or nearly so. The four causes in order of likelihood, how to tell them apart, and what to change for each.
A good prospect has no address	A qualified prospect with no contact address. Why nothing was invented to fill the gap, what the record is still worth, and the next actions that do work.
Outreach was blocked	A message to a prospect was refused or held. Which gate did it, where the reason is written, and which refusals a person is allowed to lift.
Connect refused to prospect an existing customer	A candidate was recognised as somebody the workspace already deals with. What the match was made on, and how to correct it when the match is wrong.
The prospecting allowance is spent	Prospecting has stopped because a limit was reached. Which of the two allowances it was, what carries on regardless, and what is waiting rather than lost.
Two people were treated as one	A reply that mixes up two contacts: how an over-broad identity or a bad merge causes it, and how to separate the consequences afterwards.
Something is missing from the timeline	Four kinds of event never appear on a customer timeline by design, and one kind of absence is a real gap. How to tell them apart.
An obvious duplicate was not suggested	Why two records that look identical to you share nothing a detector can match on, and how to merge them yourself without losing either side.
A person is not attached to their company	The company link is a decision somebody makes, not something inferred from an address. Where it comes from, and how to set it in each place.
Connect would not give a price	Connect would not give a price, an SLA or a warranty term. Why the refusal is correct, what evidence changes it, and how to answer the customer today.
The deal would not move stage	A deal will not move to the stage you picked. The rules that block a move, how to satisfy each one, and the stage change people confuse it with.
A deal is not on the board	A deal you expected is not on the board. Four causes checked in order: the filter, the stage, who owns the record, and which workspace you are in.
A follow-up did not go out	A follow-up came due and nothing went out. The six gates in the order they are checked, and how to tell from the row which one stopped yours.
The follow-up went out at the wrong time	A follow-up reached someone at an hour nobody intended. What the due time actually promises, and the four delays that move a send later.
The same person is being chased repeatedly	One person is being chased again and again. Where the extra commitments come from, why duplicate protection missed them, and how to stop them.
No case was opened	A customer raised a problem and no case exists. Why opening one is an action rather than an inference, and what to do when it should have happened.
A website enquiry is not in my workspace	An enquiry from the JBRH site is not in your workspace, and it never will be. What you are actually seeing, where the record is, and what it protects.
WhatsApp messages are not arriving	No WhatsApp conversations are appearing in Connect: the causes in order of likelihood, what Connect did and did not complete, and how to prove which half is broken.
The WhatsApp reply would not send	A WhatsApp reply was written and did not go: telling the 24-hour window from a consent block, a spent allowance, an unapproved template and the hourly cap.
The WhatsApp message attached to the wrong person	A WhatsApp conversation is attached to the wrong contact: why matching works from the number alone, what the wrong join affects, and the two different repairs.
SMS will not send	A text message will not go out. The provider check comes first, then DLT, then suppression — with what Connect completed and what it never started.
The same SMS was answered twice	One text message produced two answers, two follow-ups or two cases. What the deduplication key covers, what defeats it, and how to clean up without losing a promise.
The Assistant is not on screen	The Assistant launcher or panel is not where it should be: the two layout causes, the one session cause, and how to tell them apart in under a minute.
The Assistant refused to do it	The Assistant declined to do something you asked: the four kinds of refusal — authority, autonomy, evidence and plan — and which of them a person can lift.
The Assistant answered about the wrong record	An answer about a record you were not asking about: how screen context is claimed and checked, what a pinned record overrides, and how to reset both.
The Assistant stopped responding	The Assistant stops mid-answer or never starts: separating a dropped stream from a provider limit from a spent AI budget, and what each one needs.
Connect ignored what I told it	A reply that ignores something you wrote down: the four causes in order of likelihood, what to check for each, and what the reply did and did not do meanwhile.
Connect remembers something wrong	Connect keeps repeating something about your business that is not true: how to find where it is stored, correct it at the right tier, and confirm the fix.
An older fact stopped being used	Something Connect used to mention has quietly stopped appearing: the per-channel character budgets, the fixed group order, and what falls off the end first.
Connect said it does not know	A thread waiting because approved Knowledge held no confident answer: the six causes in order of likelihood, and the three things that change it.
A Knowledge source failed to process	A Knowledge source that ended in error or never went active: the format, size, content and service causes, with the repair for each.
An answer quoted the wrong thing	A reply cited something out of date, contradictory or beside the point. The causes in order of likelihood, what Connect finished, and what it never attempted.
Connect is preparing work but sending nothing	Connect is clearly working — drafts appear, calls are planned — and nothing leaves. The four causes in the order they actually apply, and how to tell them apart.
The approval is not in the queue	You are waiting for something to approve and the queue does not have it. The two states that look exactly like absence, and the four other reasons.
Connect did something without asking	Something went out with no approval. How to read the decision log entry that explains it, and why the scope in force is usually wider than the one you set.
Needs You is empty and something is wrong	An empty queue is not a clean bill of health. What Needs You raises, what it deliberately leaves to other screens, and where to look when it is quiet.
The file was refused	A file would not attach: the format list, the content check that ignores the extension, and the two safety refusals that happen before anything is parsed.
The PDF has no readable text	A PDF with no text layer still gets read, as an image, by the model. What that changes about the answer, and when to go back for a better source.
The grid would not save an edit	A cell reverted instead of saving: the service that owns the record declined the change. The six reasons it declines, and how to find which one applied.
Some imported rows are missing	Fewer records arrived than the file had rows. The three causes that account for nearly all of it, and the report that names each one by row.
A CSV export looks escaped	An exported CSV shows odd leading characters on some cells. That is formula neutralisation working, why it is not optional, and how to read the file safely.
You cannot sign in	Three different failures wear the same face at the sign-in screen: consent, the address you used, and membership. How to tell them apart in order.
You are in the wrong workspace	Why you are looking at another business's screens, how a workspace is actually chosen, and the one version of this that is worth reporting.
You were signed out	A session expires on a clock rather than on idleness, and it does it without warning. What that looks like on an open screen, and what your last action did.
The allowance is spent	A daily counter is spent. What keeps running, what is held rather than dropped, and the four things a person can genuinely do about it today.
The plan has lapsed	Four different things stop a workspace and all of them look the same from a screen. How to tell a lapse from the other three in about a minute.
A screen returned 403	A screen refuses with 403 for one audience and works for the other: which of the two boundaries refused, how to tell, and what to report.
Data that should be here is not	A record you expect is not in a list: the three different silences behind that, how to tell them apart, and the one that is a defect rather than a boundary.
An inbound webhook was rejected	A provider reports failed deliveries and nothing arrives in Connect: the four causes of a refused callback, in the order they are worth checking.
Connect appears to be doing nothing	Connect looks idle: no replies, no calls, no activity. The seven reasons, ordered by how often each one turns out to be the answer.
The same message went out twice	Two copies of one message, or one call placed twice: how retries are made safe, the two causes that produce a genuine duplicate, and what to do next.
A message went to the wrong person	A reply or a call reached the wrong person: how identity resolution and thread stickiness decide a recipient, and how to correct the record afterwards.
An integration disconnected	A connected provider has stopped working. The shape every disconnection shares, what each provider does differently, and why reconnection happens at the provider.
A provider is down	A provider Connect depends on is failing. What is handled automatically, what simply waits, and the few things a person should and should not do meanwhile.
The AI provider refused	The AI provider refused. Quota, a rejected key, the spend ceiling and a bad model choice produce one symptom — here is how to tell which of the four it was.
The AI budget is spent	The AI spend ceiling has been reached. What stops immediately, what carries on untouched, and the sentence a caller hears instead of a conversation.
A screen is slow to load	A screen that takes seconds to appear: what it is actually fetching, the two query patterns that make screens slow, and how to tell which one you have.
A screen is empty and should not be	A list showing nothing when it should show rows: the four causes — a filter, a workspace stamp, a permission, or genuine emptiness — and how to tell them apart.
The screen shows old data	The screen shows something you know has changed: the five reasons old data appears, including a tab that never noticed a release and a record still being written.
The layout is wrong on a phone	Overlapping or unreachable controls on a phone: where the layout comes from, the breakpoint that matters, and the four details that make a report reproducible.
Keyboard navigation gets stuck	Tab stops working or focus vanishes: how to tell a real focus trap from focus you cannot see, the reliable way out, and what a useful report contains.
Search returns nothing	Search returns nothing for something you know exists: which fields are actually matched, how wildcard characters behave, and why results are a page rather than a set.
An export is missing rows	A download that is shorter than the screen suggested: what an export actually follows, why the visible rows are not the set, and the cells that change on the way out.
There is no audit entry for something	No audit entry for something that clearly happened: which of Connect's three self-records holds it, what the audit trail deliberately excludes, and what an absence proves.
A time is shown in the wrong zone	A clock reading that looks an hour or half a day out: which zone each surface uses, why a promised call-back follows the line rather than the caller, and what to check.
A duplicate record was created	Two records for one person or company: the three ways a second one is created, what merging does to history, and what to check before you merge.
You do not have permission	Three unrelated things produce 'you do not have permission': your audience, your workspace and your role. Each looks different once you know what to look at.
Something will not delete	Something refuses to be removed: what Connect protects and why, which removals are marks rather than erasures, and what to do instead of deleting.
The call sounded bad	When a call sounded bad: separating band-limited telephone audio from network trouble, turn-taking faults and delivery, and what Connect can actually measure.
The reply lost its formatting	A message that looks plainer than it should: what the reading sanitiser removes, what the composer never adds, and how to tell lost styling from lost content.
The memory viewer shows nothing	You opened the memory viewer expecting to see what Connect knows and found nothing. Which tier you are actually looking at, and when empty is the true answer.
An MCP client cannot connect	An MCP client that will not talk to Connect: the four refusals it can meet — transport, origin, protocol version and authentication — and the one-line test for each.

Email#

Page	What it covers
Mailboxes	What one mailbox row owns, how several run at once in a workspace, what changes when you add another, and the defect that made a connected mailbox invisible.
Mailbox roles	Why a mailbox carries a role, what the role changes about which address a reply leaves from and how it is written, and how to choose one deliberately.
The primary mailbox	What falls back to a workspace's default sending mailbox, how that default is expressed and changed, and what to do when a workspace appears to have none.
Connecting Gmail	Connecting a Google mailbox: the consent path, why signing in and connecting a mailbox are different acts, and what the mailbox row holds afterwards.
Gmail OAuth scopes and why each is asked for	The permissions a Google mailbox connection asks for, the capability behind each one, and precisely what stops working when one is withheld or withdrawn.
Connecting an IMAP and SMTP server	Connecting a mailbox on your own mail server: the two halves of the connection, what a saved connection proves, and the ladder of checks that proves the rest.
Connecting a Microsoft mailbox	Connecting a Microsoft mailbox over Graph: what the adapter covers, the two places it differs from Gmail, and the much larger part that is identical.
Mailbox signatures	Where a signature is stored, which messages it is applied to, how it interacts with a reply you have edited, and what this documentation can and cannot say about footers.
Autonomy on one mailbox	Giving one address its own rule about what Connect may do: how the endpoint scope resolves against the channel and the workspace, and when it is the right tool.
Mailbox health	Why a mailbox that authenticates can still be failing, what the health verdicts on the row are derived from, and which action each situation actually calls for.
A quiet mailbox	A mailbox that authenticates and returns nothing: what the state means, the four ordinary reasons for it, and why it is reported as a signal rather than an error.
Disconnecting a mailbox	Removing a mailbox from a workspace: exactly what stops, exactly what is kept, what happens to work in flight, and the safer order to do it in.
Syncing an inbox	How a mailbox is read: what the first pass does that no later pass repeats, what each pass fetches, and what bounds a single pass rather than letting it run away.
Gmail history sync	How a Gmail mailbox resumes by history ID instead of re-reading, what a gap in that history means, and what has to happen when the provider can no longer answer.
IMAP UID and cursor lifecycle	The UID cursor on an IMAP mailbox: what it records, the only outcome that advances it, and the two server-side events that can invalidate it entirely.
Large batches and bursts	What happens when hundreds of messages arrive at once: the two different orderings involved, why screen cost stays flat, and what a burst can genuinely distort.
From a provider message to a canonical one	The journey from a provider's own message record to the canonical thread, message and contact the engine reads — and why the engine is not allowed near the provider table.
Conversation threads	How a canonical thread is formed, which signals attach a message to one, what a person's own marks on a thread control, and the ordinary ways a thread breaks.
Resolving a sender to a person	How an email address becomes an identity, an identity a person and a person part of a company — and what happens the first time a stranger writes to you.
Rendering HTML email safely	How Connect renders an HTML message: what the sanitiser removes, why remote images never load from the sender, and what you read instead.
Remote images in email	Why an image in a received message loads through Connect's proxy instead of your browser, and what that changes for the sender and for you.
Email attachments	What Connect records about a document attached to an email, what it deliberately does not keep, and what a reply looks like when the enclosure was the message.
Triage and priority	How a thread gets a priority, why `threads.priority` changes what the engine does next, and which triage marks belong to you alone.
Blocking a sender	Blocking a sender writes a memory row tagged block:email, not a column — which is why it holds across channels and across future conversations.
Giving guidance on a thread	The one-line direction you give on a thread: where it is stored, how far it reaches, and when it should be a standing instruction instead.
How a reply is drafted	What goes into a reply before a word of it is written: the thread, grounded knowledge, memory at four tiers, the rules — and the answers Connect declines to give.
Held drafts	What happens to a reply Connect has written but is not allowed to send yet: where it waits, what the recipient sees, and how it is released.
Editing a draft before it goes	Changing a reply before it goes out: which fields are editable, why the sending mailbox is not, and what your edit does to the record.
Approving and rejecting a draft	The two decisions on a waiting reply, what each one records, why a rejection is not a lesson, and who is accountable afterwards.
Regenerating a draft	When writing a reply again is the right move rather than editing it, what a fresh pass picks up, and what regenerating costs you.
Sending email	The path an outbound message takes through Connect's single send boundary, the checks along it, and the narrow meaning the word sent may carry.
Proof that a message was sent	Why Connect will not call a message sent without the provider's own acknowledgement, what the third state means, and how a message in doubt is resolved.
A send that failed	A message that did not go: the failure classes, which ones are worth another attempt, what Connect completed anyway, and where the failure appears.
Writing back to Gmail	After Connect answers a Gmail thread it labels it and marks it read in the customer's own mailbox — and a failure to do so never blocks the reply.
The daily email allowance	What the daily email allowance counts, what happens when it is spent, and why the read cursor deliberately stays where it is on a refusal.
Following up by email	Creating a dated commitment to write again, what is drafted when it falls due, and the reference rule that stops the same follow-up existing twice.
Outreach email versus a customer reply	Outreach and a reply to a customer are two paths with different gates. What each must pass, why they are never merged, and what that costs in volume.
Unsubscribe	How Connect honours an unsubscribe: the request is acted on rather than answered, a do-not-contact entry is written, and every send path checks it.
Spam complaints	What a spam complaint changes in Connect: escalation instead of a reply, a suppressed address at the provider, and a reputation state that can stop outreach.
Bounces	What Connect does when a message comes back undelivered: permanent against temporary failure, which one takes an address out of use, and how a person clears it.
The suppression list	The one list checked before any outreach: what puts an address on it, what it blocks, who may take an entry off, and how it differs from blocking a person.
Do not contact	The strongest entry in Connect's compliance record: what a do-not-contact instruction stops, how it is set, and why the Connect Assistant cannot lift one.
Deliverability	What Connect controls about whether mail arrives, what belongs to your own sending domain and its history, and the order worth fixing things in.
Email for the Owner and for a customer	Email runs on one implementation behind two doors. What the plan changes for a customer, what is identical, and where the asymmetry has actually gone wrong before.

Prospects#

Page	What it covers
Describing who you want to reach	What a discovery brief holds, which parts become hard filters and which only steer research, and how to write one that returns real work.
Location and scope	How a place in a discovery search is interpreted, what widening it actually costs, and why a tighter area usually returns more usable prospects.
Discovery running in the background	Discovery that runs on a schedule rather than on a button: what it does between visits, what it consumes, and how you see progress.
Collecting candidates	The stage between a search and a researched prospect: where a candidate comes from, what is stored about it, and what is deliberately left undecided.
Researching a candidate	What Connect reads about a candidate, what it extracts, and why text fetched from a stranger's website is treated as data rather than instruction.
Evidence on a prospect	Why every claim on a prospect carries the source it came from, what qualifies as backing, and what happens to a statement that has none.
Qualifying a prospect	How researched claims become a fit judgement and a score, what the score is allowed to decide on its own, and how a person overrides it.
Why this prospect	The sentence explaining why an organisation is on your list: what it may cite, what it is forbidden to say, and how to fix one that reads wrong.
Contactability	The gap between a business you can research and one you can write to, why the two counts differ, and what to do with the difference.
Connect does not guess email addresses	Connect never constructs a prospect's email contact from a name and a domain. What that rule costs, what it buys, and what happens to a prospect without one.
Evidence for a contact address	How a prospect's address earns its place: where it was found, how that origin is stored, and what makes one address usable and another not.
Finding the right person	How a role at a prospect is inferred from public material, why it is recorded as an inference, and what that means for who a first message names.
Deep research on a prospect	The second, deeper pass over a prospect: what it adds, what it consumes, and the rule that decides which candidates are worth it.
The angle for first contact	The opening line of a first message: how it is grounded in sourced claims, what it is refused permission to say, and what makes one read as automated.
Sender readiness	The checks that stand between a written first message and a send: which mailbox, whether it is healthy, what allowance is left, and which signature applies.
The compliance check before outreach	Do-not-contact, suppression, unsubscribe, complaints and prior contact, all checked in one place before any outreach leaves a workspace.
First outreach	The first message to a prospect: what goes out, what is held and why, and what is written to the record in both cases.
A prospect replies	What happens when a prospect answers: how the reply is classified, what it changes about the record, and which answers end the cold path immediately.
Stopping a cold sequence	Every event that ends a cold outreach sequence, why each takes effect at once rather than at the next scheduled step, and how to confirm one stopped.
From prospect to opportunity	When a researched prospect becomes a deal on the pipeline: what is created, what is linked rather than copied, and what deliberately stays behind.
Uploading your own list	Bringing a list you already own into Connect: the file, what is checked on every row, what happens to a row that fails, and what is never added.
The prospect record	Every part of a prospect record, which parts a person supplied, which came from research with a source attached, and which are recalculated.
Keeping prospect research fresh	Prospect research ages at different speeds. What is re-checked, what is left alone, and the control that stops re-research becoming a standing bill.
Resolving a prospect to an existing relationship	The check that recognises a discovered organisation as somebody you already deal with, what it matches on, and what happens when it fires.
The numbers above the list	What each headline number above the prospect list counts, and the paging defect that once made every one of them stop at five hundred.
What prospecting costs	Where prospecting spends money, how the cost router decides a deeper pass is worth running, and which screen shows what a run consumed.
Prospecting for the Owner and for a customer	Prospecting is one implementation serving two audiences. What is identical, what the plan bounds, and why a tenant sometimes sees a 403 instead.

Relationships#

Page	What it covers
People	The person record: what you type, what Connect derives, what attaches from other services, and why blocking somebody is not a field on it.
Companies	The company record, how several people attach to one organisation, what belongs to the company rather than to a human, and when not to create one.
Identities	One address on one channel is its own row: how identities attach to a person, how they are keyed, and what happens when one is attached to the wrong human.
One person across phone, email and WhatsApp	How the same human is recognised when they arrive on a second channel, what counts as evidence, and why a likeness is a proposal rather than a match.
Customer 360	One person's whole history in a single view: what is assembled into it, which service each part comes from, and what it deliberately leaves out.
The customer timeline	What appears on a person's timeline, where each entry comes from, the ordering rule, and the query cost that once made this screen expensive.
Duplicate detection	How two records come to describe one human, what a duplicate proposal is and is not, and why nothing is ever joined without a person saying so.
Merging two records	Merging two records is a human decision: who makes it, what happens at the moment it runs, what changes for every channel, and what cannot be undone.
What a merge preserves	The itemised guarantee: identities, stages, follow-ups, deals, demos, cases and onboarding all survive a merge, and what happens when both sides hold one.
Lifecycle stages	The six stages a relationship moves through, what may move it, why becoming a client needs a person, and where the history of every move is kept.
Normalising a stage	Why one column holds three vocabularies, how an unfamiliar stage word is read, and the message that went unanswered when a lookup raised instead.
The relationship summary	The written relationship summary: what it is assembled from, why it is not a stored document, and the name guard that rewrites it on the way out.
The contact brief	The short block about a person that a channel is given before it answers: what is in it, the character budgets, and why every line has to earn its place.
What Connect remembers about a person	The contact tier of memory: what Connect knows about one human, how a fact gets there, how it is read into an answer, and how anyone removes it.
Finding a person or company	Finding a person or company: what is matched, why counting and paging happen in SQL, and how a per cent sign typed in the box is treated as a character.
Relationships for the Owner and for a customer	The Owner calls them relationships and a customer calls them people: the same records, the same code, and the rewrite that makes one path serve both.

Sales#

Page	What it covers
Opportunities: the deal record	What an opportunity holds — value in minor units, stage, the people it belongs to, the review flag — and what each field is actually used for.
The pipeline board	What the board shows, what dragging a card actually calls, and why a total on a board must be counted in the database rather than in the page.
Stage rules and refusals	Why a deal will not move: the four shapes a stage restriction takes, what a refusal tells you, and why declining is a correct answer.
The next best action on a deal	How Connect picks the next thing to do on a deal, the records that evidence it, and what to change when the suggestion is wrong.
Price, SLA and warranty: what Connect may say	Connect does not invent commercial terms. What counts as grounded, what is refused and escalated instead, and how a breach is caught on a live call.
Escalating a commercial decision	What a refused commercial question looks like in Needs You, what the person deciding actually sees, and what happens to the customer afterwards.
Quotes and sales documents	A quote in Connect is a file, not a special object: what can be assembled, which terms it may contain, and where its versions and provenance live.
How a deal connects to people and companies	The links between an opportunity, its person and its organisation — what each one is for, and exactly what a merge does to them.
Follow-ups on a deal	What raises a chase on an opportunity, how the channel is chosen, and the duplicate rule that stops one customer being pursued twice for the same thing.
Closing a deal: won and lost	What each closing outcome records, what it starts or stops downstream, and what to do with the commitments the deal made before it closed.
Sales for the Owner and for a customer	The pipeline is one implementation serving both audiences. What a plan bounds, and why two commercial screens are correctly operator-only.

Follow-ups#

Page	What it covers
Creating a follow-up	The three routes to a follow-up — by hand, from a conversation, from a call — and what each one records about the promise behind it.
The reason on a follow-up	Every follow-up carries a reason. What a usable one contains, the four that are not reasons at all, and who ends up reading it.
Due dates and times	How a spoken or written promise becomes a due timestamp: the phrases that parse, the timezone it lands in, and the fallback when nothing usable was said.
Choosing the channel	Which of the six channels a commitment lands on, how a call decides it, when to use `any`, and the one channel that nothing ever sends.
Follow-ups for a person to do	The `task` channel is work for a person, and no drain ever sends it. What lands there, where it appears, and why nothing sending it is correct.
Changing a follow-up	What you can change on an open follow-up, which operation to reach for, and the one thing no operation will do — erase what already happened to the row.
Approval on a follow-up	When executing a follow-up needs a person's yes, what the approver is shown, and what a rejection does to the commitment underneath.
Executing a follow-up	What happens when a row comes due: the drain that picks it up, the gates it passes through unchanged, and the three outcomes written back against it.
Completing a follow-up	The two ways a follow-up closes as kept, the third state that looks like completion and is not, and what each one records against the relationship.
Duplicate follow-ups	What counts as the same commitment: the person and the due time. What the rule catches, what it deliberately does not, and how to work with it.
A follow-up that is too late	A phone follow-up more than twenty-four hours late is closed rather than rung. The cut-off, the reasoning behind it, and what the closed row records.
Overdue follow-ups	Where a follow-up past its time shows up, how it is ranked against everything else a person owes, and the four things that clear it.
Follow-ups for the Owner and for a customer	One queue, one drain, two doors: what is identical for the Owner and a customer workspace, what differs, and the enquiry queue that belongs to neither.

Support#

Page	What it covers
Support cases	What a support case is in Connect, what opens one, the three verbs it moves through, and how it stays attached to the person it belongs to.
What a case carries	The history an open case is answered from: what is assembled, the budget it is assembled to, and the things deliberately left out of it.
Resolving a case	What closing a case actually records, what it changes on the relationship, and the four things it deliberately leaves exactly as they were.
Escalating a case	What makes a case stop and wait for a person, what the person is actually being asked to decide, and what the customer sees while it waits.
Onboarding a new customer	The onboarding record after a deal is won: what it tracks, what Connect does between the steps, and why the plan is the workspace's rather than a template.
The relationship after the sale	What carries over when a prospect becomes a client: the record, the memory and the commitments that continue, and the four rules that change.
Website enquiries	Enquiries from the public JBRH website are held outside every workspace, on purpose. What that means, who works them, and why customers cannot see them.

WhatsApp#

Page	What it covers
Setting up WhatsApp	Connecting WhatsApp in a workspace: Official API credentials or Meta's QR-linked coexistence route, the webhook, the autonomy decision, and the test that proves it.
The WhatsApp business identity	The number, the display name and the verification mark a customer sees on a WhatsApp chat: what Meta owns, what the connection mode changes, and what Connect cannot.
Receiving a WhatsApp message	How a WhatsApp message reaches Connect: Meta's signed webhook call, which workspace it belongs to, every message type it can carry, and the record it becomes.
Recognising who sent a WhatsApp message	How a WhatsApp number becomes a named Person in your relationships, what happens when the sender is unknown, and how a wrong match is corrected.
Continuing a WhatsApp conversation	What Connect carries from one WhatsApp message to the next: the thread, the relationship, memory and knowledge — and how a long silence is treated.
Replying on WhatsApp	How a WhatsApp reply is written, what decides whether it is sent or held for approval, and what counts as evidence that it actually went.
Follow-ups on WhatsApp	Scheduling a WhatsApp follow-up: what can be promised, what Meta's 24-hour window allows, and what happens when the due time arrives and only a template will do.
Opting out of WhatsApp	What a customer can say to stop WhatsApp messages, how Connect honours it, where the suppression is recorded, and what still reaches them afterwards.
Delivery and read status	Delivery and read receipts on WhatsApp: what Meta reports, what Connect stores, what it refuses to infer, and the billed category that rides along with a status.
What WhatsApp cannot do here	The honest boundaries of WhatsApp in Connect: two things not proven in production, what Meta decides rather than Connect, and the limits that are Connect's own.
WhatsApp for the Owner and for a customer	One WhatsApp implementation, two audiences: what the Owner and a customer workspace share, what is separate, and why a test on one proves nothing about the other.

SMS#

Page	What it covers
Receiving SMS	How a text message reaches Connect: the provider webhook, the workspace it resolves to, the record it becomes, and what receiving alone does not give you.
Duplicate SMS	Why the same text message can arrive at Connect more than once, what key stops a second copy becoming a second conversation, and the one case it cannot cover.
Attaching an SMS to a person	How Connect turns the number that sent a text message into a Person, what it does when the number is unknown, and the near-misses that land a message on the wrong record.
STOP and opt-out	The opt-out words Connect honours in a text message, what is written when one arrives, how far the refusal reaches, and how quickly it takes effect.
SMS suppression	How a suppression entry is created on SMS, what it stops, how it differs from a do-not-contact directive, and who is allowed to clear one.
DLT registration in India	What DLT registration means for a business sending commercial SMS in India, the three registrations involved, and why it is a process with the operators, not a setting.
Sending SMS: what is available today	The honest state of outbound SMS: what the provider decides, why the carrier on the live account carries none, and what the Phone screen shows instead of a thread.
SMS for the Owner and for a customer	Whether SMS behaves differently on the Owner account and in a customer workspace: the same code path, the same provider limit, and the one real difference.

Assistant#

Page	What it covers
Opening the Assistant	Where the Connect Assistant lives, how the panel opens over any screen, and what it already knows about your workspace the moment it does.
Assistant tabs	Each Assistant tab keeps its own conversation, follow-up chain, record, draft, files and scroll position — and why that separation is the point.
Screen awareness	What the Assistant is told about the page you are on, and the database check that runs before any of it is allowed to shape an answer.
Working on one record	Pinning a person, company, deal or thread to an Assistant tab: what changes in the answers, what it overrides, and when to unpin.
Asking about selected text	Highlighting a passage and asking about it: exactly what leaves the page, what stays behind, and the questions it answers better than any other route.
Conversation history	What an Assistant conversation keeps, where it lives, why it is not the same thing as memory, and how to start a genuinely clean thread.
Suggested commands	The prompts the Assistant offers before you type: what they are drawn from, what they are not, and why clicking one still asks before it acts.
Answers that change nothing	Most of what the Assistant does is read and answer. The tools that can only read, how to recognise one at a glance, and why the default matters.
Where an answer came from	How the Assistant shows what an answer was built from, how to read the folded step detail, and what to do when it cannot name a source.
When the Assistant is not sure	Why an admission beats a plausible guess in a system that acts on its answers, and what the Assistant offers you in place of one.
When the Assistant finds two answers	What happens when a memory, a knowledge source and a customer's own message do not agree: what is shown, what is never decided silently, and who settles it.
Proposed actions	Anything the Assistant would change arrives first as a card: the action, the reason, the arguments you can edit, and a confirmation that nothing has happened yet.
Running an action	What happens the moment you confirm: which service runs, which gates still apply, what the result shows you, and what is written to the decision log.
Undoing an action	Some Assistant actions reverse cleanly, some cannot be reversed at all, and the line between them follows whether the change ever left your workspace.
The Assistant's tools	The Assistant has 66 tools. What the reading ones reach, what the writing ones change, and the rule that every write calls the service owning the record.
What the Assistant may not do	The Assistant is given deliberately narrower rights than the person using it: no pricing, no clearing a do-not-contact entry, and no way around a workspace's own rules.
Working with files in the Assistant	Attaching a document to the Assistant, the formats it reads, what it refuses, and where a document it creates or changes actually goes.
Correcting a fact without leaving the Assistant	Turning something you said in conversation into what Connect actually knows: which tier it lands in, how a block is stored, and what forgetting does.
Needs You inside the Assistant	The queue of decisions waiting on a person, worked from inside the Assistant panel: what is shown, what deciding there does, and what it will not let you do.
The live status line	The single line the Assistant shows while it works: what Understanding means, what the step count counts, and what Stop actually stops.
Rating an answer	What rating an Assistant answer records, who can read it, and why a correction you want to stick belongs in Memory rather than in a rating.
The Assistant on a phone and on a wide screen	Three layouts for one Assistant: full screen on a phone, a sidebar from 600px, a column on a wide screen — and how the on-screen keyboard is handled.

Memory#

Page	What it covers
The four memory tiers	Workspace, channel, endpoint and contact: what each tier is for, how tiers() resolves them narrowest-first, and why an empty tier is still returned.
Business memory	The workspace tier: what a business should tell Connect once so it holds everywhere, and the four kinds of line that do not belong there.
Person memory	The contact tier: what Connect keeps about one human, how it follows them across channels, and the 600-character block that reaches a live call.
Channel and endpoint memory	The two middle tiers: what Connect should know about a whole channel, and what belongs to one mailbox or one phone number instead.
How a memory is created	The four ways a memory gets written in Connect — by hand, by the Assistant, at the end of a call, or as a deliberate correction — and what each one records.
Memory from an email or a chat	Why an email or a chat does not silently become memory, what a person or the Assistant may take from one, and how a written instruction inside content is treated.
Memory from a phone call	What a phone call leaves behind: the end-of-call write, the two filters that stop a thin call producing facts, and the guards that refuse a misheard name.
Seeing what Connect knows	Where the memory viewer opens from, how it groups what it shows, and the second route through the Data grid when you want to read a whole tier at once.
Editing a memory	Changing a memory that is worded badly or plainly wrong: what an edit touches, what it does not touch, and when superseding is the right move instead.
Superseding a memory	Replacing a memory whose truth has changed while keeping the earlier statement readable, and why that is different from editing it in place.
Forgetting something	What forgetting actually removes in Connect, what deliberately survives it, and the two deletions that have consequences people do not expect.
Block and guidance directives	The two memories that direct behaviour rather than describe it: a block carried in the tag list, and a standing instruction carried in the text.
Where a memory came from	Why every memory needs an answer to 'who said so': the four origins, what the record keeps, and how to write a row that explains itself later.
How memory reaches a reply	The door memory goes through on each channel, the character budgets on the voice path, and why instruction size is a latency decision rather than a preference.

Knowledge#

Page	What it covers
Knowledge sources	What can be added as a Knowledge source, the size ceiling for each kind, the authority and scope it is given, and why one stops answering.
Extracting text from a source	How a file becomes text: direct decoding for Markdown and plain text, model reading for PDF, image and video, and the limits on both.
How Knowledge is prepared for retrieval	What Connect actually builds from a source: heading-aware passages in the same database, no vector store, and an optional embedding column.
Retrieving Knowledge for an answer	What is fetched for one question: eligibility, the scoring terms in order, the three labelled blocks, and why a live call gets only four entries.
Testing retrieval	The search tool that shows what a question would actually fetch, how to read its score and authority columns, and what it cannot tell you.
The facts editor	Typing a short grounded statement directly: the fields, what priority and keywords actually do, and when this beats uploading a document.
Knowledge and Fact are different things	Knowledge is the body of material a workspace supplies; a Fact is one statement inside it. Blurring the two produces confident, unsupported answers.
When two sources disagree	Contradiction detection when a source is added, why a conflicted source stops answering, and why nobody but a person may decide the winner.
Claims Knowledge does not support	What happens when an answer would need something Knowledge does not carry: no draft is written, a person is asked, and the miss is recorded.
Who decides what is true	Authority is set by a person and enforced in code before the model sees anything, which is why no document and no message can promote itself.
Instructions hidden in content	Received and fetched text is data, never instruction. What is stripped, what is flagged, what stops before any model runs, and what none of it guarantees.
Knowledge for the Owner and for a customer	One Knowledge implementation reached by two routes: what is identical for both audiences, what a plan scopes, and where a customer workspace stops.

Autonomy#

Page	What it covers
The four autonomy modes	Off, draft only, ask before sending and autonomous: what each does to an outbound action, and the difference readers most often miss.
Autonomy scopes	Contact, endpoint, channel and workspace: the four levels an autonomy rule can be set at, and why the narrowest one always wins.
Setting autonomy per channel	Email, WhatsApp, SMS and voice each carry their own autonomy mode. Why they usually should not match, and the configurations that work.
The gates that always apply	Suppression, blocks, allowances, evidence and workspace isolation: the refusals that stand even when a channel is set to autonomous.
Asking before placing a call	Holding outbound calls for a human yes: what the setting covers, what the approver is shown, and what happens to a call-back that waits too long.
Exceptions to a rule	Overriding a channel rule for one contact or one mailbox: when an exception is the right instrument, and the three tools often confused with it.
Autonomy and spend	Permission and capacity are separate controls: how the plan allowance and the workspace budget limit what an autonomous channel actually does.
Approvals	Waiting For You: how a held action is presented, what a person may change, the two decisions available, and what each one records.
Editing before approving	Changing a prepared reply before releasing it: which parts a person may alter, what the edit records, and when to regenerate instead.
Rejecting an action	Saying no to a held item: what happens to the prepared work, what is written down, and whether Connect tries the same thing again.
Needs You	One ranked place for everything wanting a person: held decisions, mailboxes needing attention and line health, each clearing as its cause resolves.
How Needs You is ordered	Why the list is not in arrival order: the signals that push an entry up, the ones that pull it down, and how your own triage feeds back into it.
What appears in Needs You	Every sort of entry the attention list carries, what each one means, and the screen you go to in order to make it go away.
The decision log	What was decided, by what, under which rule, and what happened — including the refusals, because a refusal is a decision like any other.
How long the record is kept	How long decision records last, what actually limits an investigation, and why no age-based deletion schedule is published for them.
Standing instructions	Durable directions a person gives Connect: where they apply, how to write one that can be acted on, and how they differ from memory and autonomy.
Turning Connect on and off	The runtime switch: what stops when you turn Connect off, what carries on regardless, and the four things it deliberately does not change.
Autonomy for the Owner and for a customer	One implementation serves both audiences: a customer gets the same modes, scopes, queue and log, with the plan bounding volume rather than permission.
Who may change what	Who is allowed to change autonomy, decide a held item and read the record — and the rights the Connect Assistant is never given.

Files and data#

Page	What it covers
Adding a file	Three ways to add a file — button, drag-and-drop, paste — what happens the instant it lands, and the checks it must pass before anything reads it.
File formats Connect reads	Every file format Connect reads, what is actually extracted from each one, and the limits worth knowing before you rely on an answer drawn from it.
Validating a file	What Connect checks about a file before any parser touches it: the type check against the bytes, and the two structural attacks the checks exist to stop.
Parsing a file safely	Three refusals that keep document handling safe: external entity declarations, archives that expand out of proportion, and formulas neutralised on the way out.
Previewing a file	What a file preview shows and what it deliberately does not: stored bytes for an image, extracted content for a document, and nothing fetched from the network.
Reading text out of a document	How words come out of a PDF, a DOCX, a PPTX or a plain file, what reading order means in practice, and what happens when a document has no text layer at all.
Reading tables out of a file	How XLSX and delimited files are read into rows and columns, what survives the trip, and the four things that are reliably lost on the way.
Understanding an image	How Connect reads a photo or a screenshot: the image formats it accepts, what the model is actually shown, and the questions a picture cannot answer.
Answering from a file	Grounding an answer in an attachment instead of in a model's memory: how Connect quotes a file, what happens when the file does not say, and what a citation means.
Creating a file	How Connect produces a file: what it can be built from, which formats it will and will not write, and where the finished document lands.
Changing a file	Why changing a file in Connect always produces a new version instead of overwriting it, and exactly what the version you started from keeps.
File versions	The version chain a file keeps in Connect: what one version records, what provenance means here, and how the chain relates to the audit trail.
Linking a file to a record	Attaching a file to a company, a deal, a case or a conversation: what the link changes, what it does not, and where the file actually lives.
The record of a file	The trail a file leaves in Connect: who added it, who changed it, what was refused, and what was produced from it — and what the trail deliberately does not hold.
The Data grid	The Data screen: an Excel-like grid over thirteen record sheets, what each sheet holds, and why it is a view of Connect rather than a second database.
Columns, order and visibility	Arranging a sheet on the Data screen: resizing, reordering, hiding and showing columns, what a hidden column still does, and how to keep an arrangement.
Filtering and searching a sheet	Narrowing a sheet on the Data screen: how filters on several columns combine, how search differs from a filter, and why a typed wildcard is just a character.
Sorting, grouping and freezing	Ordering rows, gathering them under a shared value and pinning the columns you read against — and what happens when you use all three at once.
Saved views	What a saved view on the Data screen keeps, why it grants nobody any access they did not have, and how to get a sheet back to how it arrived.
Editing in the grid	Changing a value in a cell on the Data screen: which fields accept an edit, which service actually performs it, and why some edits are refused.
Bulk selection and actions	Selecting many rows on the Data screen and acting on them at once: how a bulk change is applied row by row, and what a partial result means.
Importing and exporting	Getting records into and out of the Data screen: how an import is validated row by row, and why an exported CSV escapes cells that begin with an equals sign.
Duplicates in the grid	How the Data screen surfaces records that look like the same person or company, what merging actually does, and why it is never done automatically.
The grid on a small screen	What the Data screen becomes on a phone: the controls that survive the loss of width, the ones that are dropped, and why dropping them is the right answer.

Account#

Page	What it covers
Signing in with Google	Google is the only way into Connect. What the sign-in asks for, what is kept afterwards, and the four reasons it can refuse you.
Sessions	A signed-in browser, how long it stays signed in, what ends one, and why your other devices are unaffected by anything that happens to this one.
Signing in as somebody else	Signing in as a different person on the same browser ends the session that browser was holding — that one only, never that person's other devices.
How your Google account binds to a person	Connect binds one Google identity to one user on first sign-in. Where that binding is stored, why there are two stores, and what a mismatch means.
Which workspace you are in	Every request runs inside exactly one workspace. How that one is chosen from your memberships, and why a second membership stops a sign-in rather than offering a choice.
The operator's workspace and a customer's	One codebase serves the platform operator and every customer. The feature set is identical; the difference is commercial, plus two screens about running the platform.
Workspace administration	Memberships, roles and what an administrator may change — and the deliberate limit: no member management on the account screen.
Your profile	What Connect keeps about you personally is deliberately small. Where the line falls between your details and the workspace's, and why the signature is not yours.
Security settings	The security controls a person genuinely has: the list of live sessions, one action that ends all the others, and what to do the day a device goes missing.
Your plan	A plan decides how much a workspace may do, never what it is allowed to do. What that distinction covers, and the one place it is easy to get backwards.
Entitlements and runtime choice	Entitlement is what your plan grants; runtime is what your workspace has switched on, and Connect acts only when both agree.
Usage and allowances	What Connect counts against a plan, how a daily allowance is reserved before the work happens, and what you see as a limit gets close.
When a plan lapses	What stops when a workspace plan is no longer live, what waits instead of failing, what is refused outright, and what is never deleted.

Security#

Page	What it covers
Workspace isolation	The boundary between two businesses is enforced three separate times. What each layer catches, and why one careful layer was not judged enough.
Multi-tenancy in Connect	One application serves every business. What is genuinely common, what belongs to exactly one workspace, and where the data model draws that line.
Row-level security	The database applies its own workspace filter beneath the application. What that catches which application code structurally cannot, and what it refuses to write.
The customer facade	A customer session is served through a closed surface: what is not explicitly permitted is refused, and the refusal says so in plain words.
Authorisation	Five different questions get called permission. The order they are asked in, which one produced your refusal, and how each one is worded.
How provider credentials are stored	Provider credentials are sealed as they are saved and never shown again. What a screen displays instead, and why the database password lives in no file.
Proving a phone number belongs to a workspace	How Connect proves a phone line really belongs to the workspace being served, and the class of defect that check exists to prevent.
Proving a mailbox belongs to a workspace	The scoped lookup that replaced a bare fetch on four mailbox routes, what it prevents, and the single webhook still allowed to resolve differently.
Verifying an inbound webhook	What an inbound provider callback has to prove before Connect acts on it: origin, freshness, single use and a known route, plus one named exception.
Who can read the audit trail	Who can read the record of what Connect decided and did: the two doors onto one trail, what each shows, and what the trail deliberately does not hold.
Public and authenticated surfaces	Which Connect surfaces answer without a session, which require one, and which are deliberately closed — with the rule that decides where a new surface belongs.
What is kept and for how long	How long each class of record survives in Connect, what deleting something actually does, and the two classes that are deliberately kept longest.

Product#

Page	What it covers
How Connect works	One pass through Connect in plain language: how a message becomes a canonical record, a grounded decision, a permitted action and an audit entry.
Channels	The five ways Connect reaches people — email, phone, WhatsApp, SMS and a browser softphone — with the status, the provider and the honest limit of each.
The records Connect keeps	Everything Connect writes down: the workspace root, the thirteen record sheets, the two shapes of mail, and how a person, a company and a conversation relate.
What Connect decides on its own	The decisions Connect makes without asking — priority, classification, wording, timing, research depth — and the gates that sit around every one of them.
What a person always decides	The decisions Connect never takes: price and terms, money and law, suppression, the rules themselves — each with the reason it is reserved for a human.
One product, two audiences	JBRH runs its own business on Connect and sells the same product. One feature set, one implementation, two routers — and a difference that is purely commercial.
Current limits	Every current limit in Connect, by channel and capability: what is not available, what depends on a provider, and what is deliberately reserved for a person.
Capability status	The capability register behind this manual: ninety capabilities, each labelled AVAILABLE, IN DEVELOPMENT or PLANNED, with its evidence and a machine-readable copy.
How this manual talks about the future	The four words this manual uses about a capability, what each one promises, what none of them promise, and the vocabulary the build refuses to print.
Versions and what changed	Three kinds of version live here: the product's own, the date on every page, and the specification versions the machine surfaces are written to.
Accessibility	What has actually been measured in Connect's interface — focus rings read from a focused element, contrast ratios, form-field names — and what is known to be imperfect.
Privacy inside the product	What Connect does with a workspace's material in practice: where it sits, what reaches a model, what a person can remove, and what is deliberately kept.
The data you give Connect	Every category of material a workspace supplies to Connect, the reason each one is needed, and exactly what changes if you decide to withhold it.

Getting started#

Page	What it covers
What Connect by JBRH is	Connect by JBRH in plain terms: one worker that reads mail, answers the phone and follows through — the category, and what it does not replace.
Your first hour	The four things worth doing in your first hour with Connect, in order, with the result each one produces and the mistake each one prevents.
Your first week	What to add once mail is flowing: knowledge that earns its place, standing instructions, a second channel, follow-ups, and when to loosen autonomy.
Connect your mailbox	The first real step: connecting Gmail, Microsoft Graph or an IMAP server to Connect, giving the mailbox a role, and proving that it is genuinely working.
Decide what Connect may do	The four autonomy modes, the four scopes they can be set at, and the combination most businesses should start with before anything is sent for them.
Teach Connect about your business	What to put in Knowledge first, what belongs in Memory instead, and why the difference decides whether a correction applies to everyone or one person.
Approve your first reply	Reading your first held draft, editing it, approving it, and the honest answer to what that approval does and does not teach Connect.
Set up the phone	Going from no number to a line that answers: the two voice engines, the settings that matter before the first call, and what is honestly not available yet.
Make a test call	Ringing your own line for the first time: what to say, the four things to listen for, and how to read the transcript, summary and timings afterwards.
Find your first prospects	Writing a discovery brief that returns a short list you would actually ring, and the one guarantee that shapes everything prospecting gives you.
Create your first follow-up	The four parts of a follow-up — commitment, reason, due time, channel — and exactly what happens on each channel when one falls due.
Your first pass through Needs You	Needs You is the one queue a person actually works: what lands in it, why it is ranked rather than chronological, and what an empty queue does and does not prove.
A working day with Connect	What a person actually does each day once Connect is running: one queue pass, a look at what went out, and the three habits that keep the rest honest.
A weekly review	Five checks worth half an hour every week, what each one tells you that the daily pass cannot, and the change each finding should produce.
Using Connect on a phone	Connect on a small screen: what is identical, what folds into a menu below 600 pixels, and the work that is genuinely better left for a desk.
Keyboard and speed	Getting around Connect quickly: hash routes you can type or bookmark, asking instead of navigating, and an honest note about published shortcuts.
Inviting your team	Adding colleagues to a workspace: what an invitation really grants, what everyone shares, how work is divided, and why a colleague sometimes sees a refusal.
What Connect will not do	The refusals that are designed rather than broken: what Connect declines in the moment, what is not built yet, and what it never claims about itself.
The nine words you need first	Nine words that unlock the rest of this manual, grouped by what they are for, with the three distinctions new users most often get wrong.

How-to#

Page	What it covers
Stop Connect immediately	The runtime switch stops new work at once without changing a setting. What halts, what is already in flight, and how to start again cleanly.
Change how Connect writes	Tone, length and signature are owned by three different controls in Connect. Which one to change, in what order, and how to see the effect.
Change how Connect sounds on the phone	The Voice Lab splits settings that reach the engine from directions that only ask the model. How to change one, and prove it with a test call.
Add a second mailbox	A workspace can hold several mailboxes, each with its own role, signature, autonomy and health. What to set, and what changes about replies.
Send certain mail to a person instead	Make certain mail reach a colleague instead of being answered: the rules that do it, how narrow each is, and what the exception looks like.
Block someone	A block is one directive stored against the person, tagged per channel, so it holds on email, WhatsApp, SMS and phone and in future conversations.
Correct something Connect got wrong	Four places a correction can live in Connect — this message, this thread, this person, or the whole business — and how to pick the right one.
Stop an outreach sequence	Five ways to stop cold outreach, ranked by how fast each takes effect and how wide it reaches — and which one to use while you work out the rest.
Export your data	Exporting from the Connect data grid: which sheets, what CSV carries, and why an exported cell can look escaped when it starts with an equals sign.
Import contacts	Bringing a contact list into Connect: preparing the file, mapping columns, what identity resolution does with each row, and where bad rows end up.
Share a record with a colleague	What a link to a Connect record carries — a location, not access — and the three isolation layers that decide whether the person opening it sees anything.
Set business hours	Hours belong to a phone line, not to the workspace. What a caller hears outside them, why the message names no times, and which clock is used.
Give one customer special treatment	Give one account slower, more careful handling without changing anything for everybody else: contact-scope autonomy, memory and guidance used together.
Write a standing instruction that works	What separates a standing instruction that changes behaviour from one that reads well and does nothing — plus the three kinds that reliably fail.
Prepare for a busy period	Four things to check before a peak: the daily allowance, autonomy on each channel, line hours and capacity, and who is actually working the queue.
Find out why Connect did something	Trace an action back to the rule that produced it: what the decision log records, how to read it, and why refusals appear there as decisions too.
Test a change before trusting it	Safe ways to try a change on each channel — draft-only on mail, a test call on the phone — and how to read the result without fooling yourself.
Clean up duplicate records	Two records for one human split their history in half. Finding the pairs, merging safely, and the four things to check on the survivor afterwards.
Reduce what Connect costs you	Where Connect's spend actually goes — carried context on voice calls, prompt size, research passes — and the four changes that move the number most.
Add a second phone number	Claim a second business line: the carrier side, the channel route, the purpose that decides its voice, and the checks that prove it actually rings.
Use a different voice for each line	Give each line its own voice: what a profile actually contains, the six-step resolution order behind it, and how to prove which one ran on a call.
Update many records at once	Change many rows at once in the Data grid without turning it into a second database: selection, bulk actions, the services underneath, and what gets refused.
Attach a document to a deal	Put a quote, a specification or a signed order on an opportunity so that Connect can answer from it, and so the next version does not overwrite the last.
Ask Connect about a customer	Get an answer about one customer that is worth acting on: the question to ask first, the four follow-ups that add most, and how to tell an answer from a guess.
Find out why a reply was held	Work backwards from a reply that has not gone out to the exact setting that stopped it, in the order the holds are actually evaluated.
Write a discovery brief that finds the right companies	The four parts of a discovery brief that finds companies worth contacting, with a weak brief rewritten and the reason each change alters the result.
Serve customers in a second language	Serve customers in another language across email, WhatsApp and the phone, and test each channel separately because they fail in different ways.
Review a call properly	Read a call in the order that finds the fault: outcome, timings on the wire, review findings, then the transcript — and act on the findings a control can change.
Make sure a promise is kept	Find every commitment a customer is waiting on, check each has something behind it that will actually fire, and close the ones that no longer mean anything.
Give Connect a document to answer from	Knowledge or attachment: which one a document belongs in, how to load it so answers are grounded in it, and the retrieval test that proves it took.
Check what Connect knows about a person	Read everything Connect holds about one person, tier by tier, work out which tier is driving behaviour, and correct it so the change actually sticks.
Recover something that was removed	What can be brought back after a deletion, where it is recovered from, and the four things that are genuinely gone — with the reason each one is.
Hand a conversation to a colleague	Move a conversation to somebody else without losing the context: what transfers by itself, what you have to write down, and what the customer notices.
Set Connect up before you go away	Leave Connect running while you are away: the autonomy decision, business hours, who reads the queue, and the dated commitments that will fire without you.
Measure whether Connect is working	Five numbers Connect already reports that tell you whether it is earning its place, what each one moves with, and the vanity metrics to ignore.
Report a problem usefully	Capture the eight facts that turn a support question into a fixable one, in the order that finds the answer fastest — and the two nobody thinks to include.
Turn off one channel without turning off Connect	Switch one channel off without stopping the rest: what `off` actually does, what keeps running behind it, and the three switches people confuse it with.
Check a phone number before you go live	Prove a phone number end to end before you publish it, one segment at a time, using only a handset you already hold and the records each test leaves behind.
Review your suppression list	Read the suppression list properly: where each entry came from, which kinds may be cleared, and why most of a tidy-up is leaving things exactly where they are.

Use cases#

Page	What it covers
Never miss a business call	Answering every inbound call in hours and out: what the caller gets, what still needs a person, and the three limits that shape the whole thing.
After-hours enquiries	What a caller and an emailer actually get outside working hours, what is held until morning, and the promises Connect must not make at midnight.
Serving customers in several languages	Serving customers in more than one language across phone, email and WhatsApp: how the language is chosen, what it costs, and what is not claimed.
Responding to inbound leads quickly	Answering a new enquiry before it goes cold: what Connect can say straight away, what it refuses, and why a held draft is not a fast reply.
Outbound prospecting without buying a list	Finding and approaching new organisations from public research rather than a bought list, and the refusals that cap the volume on purpose.
Chasing appointments and commitments	Chasing appointments, call-backs and commitments across channels, with the duplicate, staleness and reason rules that keep the chasing honest.
Following up a quotation	Following up a quotation without letting the agent restate the price: the sequence, the refusal rule, and how a commercial question escalates.
Support that remembers the sale	Carrying what was learned during the sale into support: how one person stays one record across channels, and what breaks the thread when it breaks.
Covering a small team's inbox	Covering a shared inbox with a handful of people: mailbox roles, per-mailbox autonomy, and the queue that keeps a human in charge of what goes out.
Running a business on your own	One person, no colleagues to approve anything: the settings that give the widest cover for the least risk, and where the single-approver problem bites.
A business whose people are not at a desk	When the people who do the work are on site rather than at a desk: what the phone covers, what the browser covers, and what genuinely cannot be done.
A high-volume inbox	An inbox with more mail than anyone can read: how work is picked, why the allowance holds rather than drops, and what to automate first.
Communication you must be able to explain	Work where every message may have to be explained later: what is recorded, what evidence exists, and the certifications this documentation does not claim.
Operating in India	Operating in India: what DLT registration actually requires, why outbound SMS does not work on the live carrier, and which channels do the job instead.
An agency with several clients	Running several clients from one product: why each client is its own workspace, what isolation actually enforces, and what deliberately cannot be shared.
Order and delivery enquiries	Where is my order, and can I change it: answering from real data, refusing what is not known, and the order lookup Connect does not have by default.
Professional services enquiries	Enquiries for advisory and professional work: scoping without committing, reading what the client sends, and the decisions that must stay with a person.
A B2B sales team	A sales team using Connect for pipeline hygiene and follow-through, with the commercial escalation that keeps the agent out of the negotiation.
Handling applicants	Handling applicants at volume: the correspondence Connect takes on, the records it keeps, and the hiring decisions it must never be given.
Booking appointments	What Connect can agree, confirm and chase around an appointment, why it does not hold your diary, and the read-back rule that keeps a booked time honest.
Reaching dormant customers	Reaching customers who have gone quiet: the compliance checks that run first, the evidence that makes a message worth sending, and which channels can carry it.
After an event or exhibition	Turning a box of cards from an exhibition into researched, evidenced records and a first message, without a single invented email address.
Working with partners and suppliers	Pointing the same machinery at counterparties who are not customers: suppliers, partners and agencies, with the scoping and refusals that differ.
Handing work between colleagues	Giving a colleague a customer relationship mid-flight: what the record already carries, what does not transfer at all, and who ends up accountable.
A clinic or practice	Scheduling-shaped enquiries for a clinic or practice, the privacy questions to settle first, and the clinical work that must never leave a person.
Trades and installers	Enquiries answered while you are up a ladder: qualifying a job, arranging a visit, and chasing the quote afterwards without ever naming a price.
Education and admissions	Admissions-season enquiry volume, families who write in several languages, and the decisions a school must keep out of software entirely.
Property enquiries	Portal enquiries answered in minutes, qualified in the reply, and turned into a viewing commitment — with the listing-accuracy problem stated plainly.
Delivery and order status enquiries	Answering where-is-it questions from records you actually hold, refusing the ones you do not, and why an answer from a sample is worse than no answer.
Manufacturing and B2B enquiries	Technical enquiries and requests for quotation: which specification questions can be answered from documents, which are refused, and how the engineer gets involved.
Software trials and onboarding	Trial and onboarding nudges that are worth receiving: what they can be grounded in, the stop rules, and the product data Connect does not have.
A small organisation with no support desk	Coverage for an organisation where answering enquiries is nobody's actual job, and the decisions that have to stay with a named person anyway.
A business with a season	Handling a season that is ten times the rest of the year: what you widen, what capacity actually limits you, and the rules that must not move.
A business with several locations	Several branches inside one workspace: a line and a mailbox each, branch facts that stay local, and one relationship record the customer never sees split.
A franchise network	A network of independently run branches: one workspace each, what genuinely cannot be pooled across them, and why there is no franchisor console.
Reseller and partner enquiries	Inbound approaches from would-be resellers and partners: qualifying them with evidence, and the commercial terms that never leave a person.
Chasing suppliers	Outbound follow-up aimed at people who owe you something rather than owe you money: what drains automatically, what expires, and what the record proves.
Payment reminders	Reminding customers about unpaid invoices: the factual part that automates safely, the regulated part that cannot, and the evidence a dispute will need.
Asking for feedback	Asking customers what they thought: when the request is triggered, which channel can carry it, and why a reply should rarely become Knowledge.

Technology#

Page	What it covers
Digital employee	What a digital employee is as a category: a permanent role with responsibilities, memory and oversight, rather than a task-shaped agent you launch and forget.
AI agent	The AI agent concept: the perceive-decide-act loop, the three things that make one useful in a business, and the two that make one dangerous.
Agentic workflow	Multi-step work with tools and checkpoints: how an agentic workflow differs from a script, and where the human checkpoints have to sit to be worth having.
Tool calling	How a model asks for an action it cannot perform itself, what the schema is really doing, and the checks a tool must run before it changes anything.
Agent orchestration	Sequencing agent work, retrying what failed, and the single-thinker rule that stops two loops from answering the same message twice.
Context window	The span of text a model can attend to in one call: what has to be re-sent every turn, what it costs, and why a larger window is not a longer memory.
Grounding	Tying an answer to a source a person can check, and the practical difference between a grounded statement and a merely plausible one.
Retrieval-augmented generation	The retrieve-then-generate pattern, the failure modes nobody advertises, and a plain account of what Connect implements and what it deliberately does not.
Knowledge base	What a knowledge base is when an agent has to answer from it, and the properties that make one usable rather than merely large.
Structured memory	Keeping what an agent knows as records rather than as conversation history, and the operations that only become possible once you do.
Relationship memory	Memory keyed to a person rather than to a conversation, why that key changes the answers, and what it takes to hold one identity across channels.
Evidence in an agent system	What counts as evidence when software claims something happened, how it is attached to the record, and the price of a claim with nothing behind it.
Unsupported claims	Why a confidently wrong answer costs a business more than a slow one, and the controls that reduce unsupported claims rather than apologising for them.
Prompt injection	Instructions smuggled into content an agent reads, what the attack looks like when it arrives as ordinary business mail, and the boundary that contains it.
Human in the loop	Putting a person at the point where a decision is expensive to reverse, and the review-speed problem that decides whether the pattern survives contact with a working week.
Agent observability	Recording an agent's work so a decision taken weeks ago can be explained: what to capture, what is useless afterwards, and where Connect keeps it.
Agent security	The threat model for software that holds real mail credentials and takes real actions on a business's behalf, and the boundaries that keep a mistake small.
System prompts and instructions	The instruction block a model is given before it sees a message: what belongs in it, what does not, and why its size is a latency decision on a live call.
What a model call costs	What a model call is actually billed for: tokens by direction and modality, context carried on every turn, and the spending that never appears on a per-request line.
Choosing a model	The axes that decide which model does a piece of business work, how a default gets set, and what actually changes when you move one.
Speech-to-speech models	A model that takes audio in and gives audio back, with no synthesiser in the loop: what that buys on a call, and what it takes away.
Text to speech	Turning written words into speech: where a synthesiser still earns its place on a realtime call, and the three things it cannot do.
Speech recognition	Automatic speech recognition: what it does on a turn-based path, what a transcript actually is once the model speaks directly, and why it lands late.
HTTP	The request-and-response model everything here runs on, the status codes that carry real meaning in Connect, and the three that routinely mislead.
HTTPS and TLS	What TLS protects on the wire, the four things it does not protect at all, and how a terminating proxy changes what the application can see.
REST	The architectural style behind most web APIs, what its constraints actually buy, and the four places Connect departs from it on purpose.
JSON	The data format every Connect surface speaks, and the two traps — number precision and re-serialisation — that break systems holding JSON in more than one place.
JSON Schema	Describing the shape of a payload so a machine can check it: what a schema pins down, what it cannot say, and why valid is not the same as allowed.
OAuth 2.0	Delegated access without handing over a password: the code flow, what a scope really grants, and why the refresh token is the credential that matters.
OpenID Connect	The identity layer built on OAuth 2.0: what an ID token asserts, which claim is the stable one, and where identity stops and permission begins.
Sessions and cookies	How a browser stays signed in between requests, which cookie attributes do the real work, and why holding one is not permission to do anything.
Webhooks	A provider calling you when something happens: verifying the sender, answering fast, and building a receiver that survives the same event arriving twice.
Server-sent events	A single long-lived HTTP response that the server keeps writing to: how it streams updates one way, and why Connect uses it rather than WebSocket.
WebSocket	A two-way connection that starts as an HTTP request and stops being HTTP: the one place Connect uses it, and the reason it is not used anywhere else.
WebRTC	How a browser sends and receives call audio directly: the media path, why signalling is not part of it, and the security policy that does not reach it.
SIP over WebSocket	Carrying call signalling into a browser that cannot open a UDP socket: registration, what keeps it alive, and the addressing mistakes that fail silently.
Idempotency	Why the same request arriving twice must not do the thing twice, the three mechanisms that achieve it, and the actions where it is the only defence.
Retries and backoff	Which failures deserve another attempt, which are already a final answer, and why backoff without jitter turns one outage into a second one.
Rate limiting	Caps that protect a provider, a workspace and you: the algorithms behind them, and why a 429 is a message to your queue rather than to one request.
Circuit breakers	Open, closed and half-open: how a failure counter stops a dying provider taking your own workers with it, and what Connect runs in place of one.
Canonical URLs	What a rel=canonical element actually decides, the duplicate URLs it consolidates, and the signals that quietly overrule it.
JSON-LD and structured data	Structured data as JSON-LD: what it changes, the rule that markup must match visible text, and the types not worth adding.
robots.txt	RFC 9309 in practice: what a robots file controls, the thing people wrongly believe it does, and how Connect serves its own.
XML sitemaps	XML sitemaps as a discovery aid: what belongs in one, why lastmod must be true, and when an index file becomes necessary.
IndexNow	IndexNow in full: the key file, the shape of a submission, the 10,000-URL bulk limit, and what is worth telling a search engine about.
hreflang	Language and region annotations that survive contact with reality: the reciprocity rule, x-default, and when hreflang is the wrong tool.
HTTP caching and revalidation	Freshness, validators and revalidation: how ETag and Last-Modified work, and the header that stops a browser serving a module from the last deploy.
Content Security Policy	Content Security Policy as a source allowlist: what it blocks, why inline script is the usual casualty, and why these docs carry no JavaScript.
Web accessibility	Accessible pages start with semantic HTML: name, role and state, keyboard order and focus — and the same structure that helps browser agents.
WAI-ARIA	WAI-ARIA roles, states and properties: the five rules, the patterns that genuinely need it, and the ways it makes a page worse.
Page experience and Core Web Vitals	LCP, INP and CLS explained by what causes them, plus what a text-heavy documentation site should fix first and what it can ignore.
SMTP	The protocol that moves mail between servers: envelope versus headers, what a 250 response proves, and the states after it.
IMAP	Reading a mailbox over IMAP: folders, UIDVALIDITY, flags and the cursor a client must keep — and the way a cursor loses mail.
Gmail API	Gmail's HTTP mail API: history IDs for incremental sync, labels instead of folders, and why write-back must never block a reply.
Microsoft Graph mail	Microsoft Graph as a mail transport: the folder model, delta queries, change notifications, and what differs from Gmail in practice.
MIME	Why an email is a tree: multipart structures, transfer encodings, header encoding, and the parts a reader never sees.
HTML email	What actually renders in a mail client, what is stripped, and why a mail reader must sanitise incoming HTML rather than trust it.
SPF	Sender Policy Framework: the DNS record that authorises sending hosts, the ten-lookup limit, and the claim SPF cannot make.
DKIM	DKIM signatures: what is signed, how a receiver verifies, why signatures break in transit, and how keys are rotated with a selector.
DMARC	How DMARC works: alignment against the From header, the three policies, the two report types, and the deployment order that does not lose mail.
BIMI	What BIMI actually requires before a logo appears anywhere: DMARC at enforcement, a constrained SVG, and for some clients a mark certificate.
Bounces	Hard, soft and the classes in between: what a bounce actually is, why some rejections never bounce at all, and the response each one deserves.
Complaint feedback loops	What a mailbox provider sends back when someone presses the spam button, why the recipient is often redacted, and the only correct response.
Suppression lists	The list that outranks every campaign: what belongs on a suppression list, what does not, and why entries must be hard to remove.
One-click unsubscribe	The List-Unsubscribe headers, what a one-click POST must not do, and the gap between honouring an opt-out and advertising one.
Email deliverability	The factors that decide whether mail reaches an inbox, ranked honestly: who you send to first, authentication second, content much later.
Transactional and marketing email	Why the transactional and marketing distinction governs consent, how a single hybrid message destroys it, and what Connect separates instead.
PSTN	The public telephone network as a software dependency: what you cannot do without a carrier, and the constraints a phone call imposes on an agent.
DID — a direct inward dialling number	A business phone number as a technical object: what direct inward dialling means, what renting a number gives you, and where routing is decided.
Telephony carriers	What a telephony carrier actually supplies, which capability differences change your architecture, and why you should ask rather than assume.
SIP	Signalling for calls: SIP methods and responses, why it carries no audio, what registration binds, and what a host:5060 URI means.
RTP and media transport	How call audio really travels: small UDP packets, a jitter buffer that costs latency, and loss that is concealed rather than repaired.
SIP trunks	Inbound and outbound SIP trunks: what an origination URI is, what a dispatch rule decides, and the configuration mistakes that fail silently.
DTMF	Keypad tones: how a digit is encoded, the three ways it travels, and why a voice agent should mostly listen instead of asking for keypresses.
Realtime voice agents	How a speech-to-speech voice agent is actually assembled, what each part is responsible for, and the failure surface a live call exposes.
Voice activity detection	Voice activity detection decides one thing — speech or not speech — and the choice of where it runs shapes what a voice agent can react to.
End-of-turn detection	Deciding that a caller has finished rather than paused: silence timers against semantic endpointing, and why this dominates perceived latency.
Barge-in	Interrupting a talking voice agent: the two ways it fails, how an ignored interruption is measured, and why resuming afterwards is usually wrong.
Voice latency	Where the seconds go on a voice call: the measured components, the floor no setting removes, and why a transcript is the wrong place to measure from.
Session resumption	What a realtime model session is, why a server ends one mid-call, and how a resumption handle carries the conversation across the reconnect.
Context compression on a live call	Why a live model is re-billed for its whole context every turn, what a compression trigger and target do, and why the trigger has to be sized.
Call transcripts	What a call transcript contains on a speech-to-speech call, what it is reliable evidence for, and why timing read from transcript rows is wrong.
Voice profiles	How a voice profile splits into session parameters the engine enforces and written directions the model only approximates, and which setting wins.
Multilingual voice	How a call's language is chosen and changed: language tags, the gap between language and script, code-mixing, and what counts as evidence of a switch.
Call routing	How a ringing number becomes a workspace, a line and a handler, and why direction, opening hours and worker capacity are part of that decision.
Provider webhook signatures	How a provider signs a webhook, how to verify one without introducing a hole, and why a valid signature still does not stop the same event arriving twice.
Call quality measurement	Two different things are called call quality. What a conversation review can measure on the wire, what a network metric measures, and what neither can judge.
WhatsApp Business messaging	How business messaging on WhatsApp actually works: the 24-hour window, pre-approved templates, opt-in, and Meta's coexistence route for a number already on a phone.
Message delivery status	Sent, delivered, read, failed: what each state is actually evidence of, why the ladder differs per channel, and why a late status must not overwrite a decision.
SMS	How the short message service actually works: the 140-octet payload, the alphabets, what concatenation costs, and why one emoji halves your message.
STOP and opt-out keywords	The opt-out words a recipient may send, what honouring one actually requires, and why your suppression list and the operator's can quietly disagree.
DLT — Distributed Ledger Technology registration in India	India's distributed-ledger registration for commercial messaging: what the regulator requires, who registers what, and why an unregistered message is rejected upstream.
Sender IDs	The four kinds of sender identity a recipient can see, why an alphanumeric name cannot be replied to, and what changing one costs you.
PostgreSQL	What a relational database buys a multi-tenant application, which PostgreSQL features this system actually depends on, and the costs that come with them.
Relational data modelling	Normalisation in plain terms, what a foreign key is really buying, and the three places this system keeps a second copy of something on purpose.
Row-level security	How a database enforces who may see which rows: the mechanism, why FORCE matters, the difference between USING and WITH CHECK, and what it cannot protect.
Multi-tenancy patterns	Shared schema, separate schema or separate database: what each isolation pattern actually costs, and why the pattern is never the security control.
Encryption at rest	Which threats storage encryption actually removes, the three layers it can be applied at, and why an authenticated query reads plaintext no matter what.
Secret management	Where a credential should live, how rotation is supposed to work, and why a convenience copy of a rotated password becomes a fuse that blows at the next restart.
Credential rotation	Why a password is read from a managed secret at boot rather than kept in a file, what a stale copy breaks, and how OAuth tokens rotate themselves.
Authorisation models	Allowlists, roles, scopes and row policies compared by the failure each one produces, and how Connect layers three of them over one request.
Audit logs	The four things an entry needs before a log counts as an audit trail, why refusals belong in it, and what turns the same file into a liability.
Provenance	Recording where a statement came from, why the origin has to survive an edit, and how Connect attaches evidence to facts, memories and files.
Reversible and irreversible actions	The three-way taxonomy an agent needs before it offers undo: what can be withdrawn, what can only be corrected, and what a person must approve first.
Versioning	Three problems that share one word: versioning a document, versioning a record, and versioning an interface other people have already built against.
Data residency	What residency, sovereignty and localisation each mean, which parts of a system they actually constrain, and the questions worth asking a supplier.
Personal data	What counts as personal data, the eight places it collects in a communications system, and the handling rules that keep the collection from spreading.
Schema migrations	Migrations that run at every boot, why every guard has to be idempotent, and the expression index a reflection API cannot find for you.
Backups and restore	What a backup has to contain before a restore actually works, the parts that live outside the database, and the rehearsal that turns a hope into a fact.
Observability	Metrics, logs and traces are built around requests; this system's unit of work is a conversation. What changes, and where the signals actually surface.
Query cost	Counting statements instead of timing a machine, the N+1 that grows with the business, and four measured before-and-after numbers from this system.
Virtualised rendering	Drawing only the rows a screen can show, the four things that break when you do, and why virtualising the view never fixes an unbounded query.
CORS	What the same-origin policy stops, what a preflight is really asking, and why an Allow-Origin header protects a browser rather than a server.
DNS	The record types a business communications setup actually depends on, and why TTL is an operational commitment rather than a number in a form.
Unicode, scripts and transliteration	Why a language and a writing system are different things, what normalisation and collation actually decide, and how both show up in a call transcript.
PDF text extraction	PDF stores positioned glyphs rather than a document, so extraction is reconstruction — and a scanned page has no text in it at all to reconstruct.
Office Open XML	DOCX, XLSX and PPTX are ZIP archives of XML parts. What each one holds, what a reader can get from it, and the two archive attacks that get refused.
CSV formula injection	A CSV cell that begins with an equals sign becomes a formula when a spreadsheet opens it. The attack, the neutralisation, and why an export looks escaped.
Identifiers	UUIDs, sequential keys and opaque identifiers compared, and the rule that saves the most trouble later: never parse an identifier you were given.

Protocols#

Page	What it covers
Model Context Protocol	What the Model Context Protocol is, what revision 2026-07-28 changed, and exactly which tools Connect exposes over it at POST /mcp.
MCP transports	The two MCP transports — stdio for a local process and Streamable HTTP for a remote server — and what revision 2026-07-28 took out of the HTTP one.
MCP tools	How an MCP tool is defined — name, title, description, input schema and annotations — and why a client must treat every one of those fields as untrusted.
MCP resources	MCP resources and prompts: what each is for, when a resource is the better answer than a tool, and the four resources Connect publishes.
MCP security	Origin validation, authentication, scoping and blast radius for an MCP server — and the one tool nobody should build, whatever the request sounds like.
A2A — the Agent2Agent protocol	The Agent2Agent protocol 1.0.0: how one agent finds another, asks it something in words, and why it sits beside MCP rather than replacing it.
The A2A Agent Card	The A2A Agent Card: where it lives, the fields that matter, how Connect generates its own, and what must never appear in a public card.
A2A agent discovery	The three ways one agent finds another under A2A — a well-known URI, a curated registry, or direct configuration — and which one Connect supports.
JSON-RPC 2.0	JSON-RPC 2.0, the envelope MCP and A2A both sit on: request, response, notification, the reserved error codes and how Connect maps them to HTTP.
OpenAPI	OpenAPI as a description format, why Connect publishes 3.1.0 rather than the newer revision, and the difference between a public contract and an internal route map.
Arazzo	Arazzo 1.1.0 describes a multi-step sequence across API calls machine-readably — the order, the criteria and the outputs that carry between steps.
AsyncAPI	AsyncAPI 3.1.0 describes event and webhook interfaces — channels, operations and message envelopes — and Connect publishes one for its outbound webhooks.
OAuth for agents	Delegated access when the client is a program rather than a person: what OAuth gives you, what it does not, and how Connect handles machine callers instead.
Streamable HTTP	The Streamable HTTP transport in detail: one POST endpoint, the three MCP headers, when a response streams, and how a call is cancelled without a session.
llms.txt	llms.txt is a community proposal, not a standard, and Google has said no Search system reads it. What it is for, and why this site publishes one anyway.
Well-known URIs	RFC 8615 and the /.well-known/ prefix: why fixed paths need a registry, what lives there on this site, and what does not belong there.
RFC 9309 — the Robots Exclusion Protocol	What RFC 9309 actually standardises about robots.txt — matching rules, status-code handling, size limits — and the parts people quote that are not in it.
Schema.org	The Schema.org vocabulary in JSON-LD: the types this documentation actually emits, the ones deliberately refused, and the rule that structured data must match the page.
Scheduling formats	Where date and time interchange appears in Connect: RFC 3339 instants on the wire, due times on follow-ups, and why iCalendar does not appear at all.

Glossary#

Page	What it covers
Connect	What the name Connect covers: the product, the operator behind it, the work it does across four channels, and the names it is not.
Digital employee	The role-shaped definition of a Digital Business Employee, and the line that separates one from a task agent, a copilot or an automation.
Workspace	The isolation root in Connect: what belongs to one workspace, how the boundary is enforced three times, and what deliberately sits outside it.
Owner	Owner in Connect means the platform operator's own workspace and session — what that changes, and the three things that are correctly operator-only.
Tenant	Tenant is the engineering word for a customer workspace: where it appears, why the product says customer instead, and what it is not.
Needs You	Needs You is the ranked queue of decisions, approvals and operational problems waiting for a person — what qualifies for it and how it empties.
Standing instruction	A standing instruction is a durable direction a person gives Connect — how it differs from a memory, from a rule and from an autonomy setting.
Memory	Memory in Connect is what it knows about a business and its people, held at four tiers and resolved narrowest-first — readable and erasable at each one.
Knowledge	Knowledge is the source material a workspace supplies for answers to be grounded in — what counts as a source, and why it is not the same as memory.
Fact	A fact in Connect is one grounded statement with provenance, extracted from knowledge or a conversation — and correctable on its own.
Rule	A rule in Connect constrains behaviour rather than granting permission — where rules are written, and how they differ from filters and from autonomy.
Autonomy	Autonomy is the per-channel rule for what Connect may do without asking: four channels, four modes, four scopes, narrowest scope wins.
Approval	An approval is one held action waiting for a human yes or no — what holds it, what the recipient sees meanwhile, and what a rejection does.
Conversation	A conversation is Connect's channel-agnostic unit of exchange — one continuing exchange with one person, whether it arrived by email, WhatsApp, SMS or phone.
Thread	A thread is the email-shaped conversation in Connect: what joins messages into one, what does not, and the triage state the engine reads from it.
Person	A person is the canonical human record in Connect: one human however many addresses they use, and the thing every conversation resolves to.
Identity	An identity is one address on one channel that resolves to a person — and it is not your own mailbox, not a sign-in, and never guessed.
Relationship	A relationship is the ongoing connection between a business and a person or company — everything that has happened, across channels and years, in one record.
Company	A company in Connect is an organisation you deal with — never your own business, which is the workspace — and it is what people are attached to.
Prospect	A prospect is an organisation research found and kept as a candidate — held deliberately even before any contact address for it exists.
Lead	A lead in Connect is a contact captured from a conversation you were already having — a different record from a prospect, and from a person.
Opportunity	An opportunity is one commercial deal on the pipeline, with a value and one of five stages — and winning it is a change only a person confirms.
Deal	Deal is the everyday word for an opportunity. Both appear in Connect because the screens speak plainly and the model and API do not.
Follow-up	A follow-up is a dated commitment to make contact on a named channel, with the reason recorded — including one channel that never sends anything.
Support case	A support case is one post-sale thing a customer needs sorted out, with a state and an owner — and deliberately not a helpdesk ticket.
Lifecycle stage	A lifecycle stage says how far one relationship has got, in six words — and the transition into client is the one Connect may not make alone.
Customer 360	Customer 360 is one person's whole history assembled across every channel — built when you ask for it, not stored as a separate record.
Mailbox	A mailbox is one email account connected to a workspace, with its own role, signature and autonomy — and it is not the same thing as an identity.
Channel	A channel is a medium Connect communicates over. Four carry autonomy rules, one more exists for calls you make yourself, and the word is not the provider.
Provider	A provider is the external service behind a channel — the mail host, the messaging platform, the carrier. Connect keeps their shape out of its own records.
Carrier	A carrier is the telephony provider specifically — the company that reaches the public phone network, and the authority for a call's duration and cost.
Audit	The audit trail records who did what, in what capacity, to what, and whether it worked — including the refusals, because a refusal is a decision too.
Voice Lab	Voice Lab is where a workspace tunes how Connect sounds on the phone and reviews finished calls against measurements the worker took on the wire.
Disposition	A disposition is what a person decided a call was — stored apart from the engine's guess, and never overwritten by a model or a late carrier update.
Outcome	An outcome is the engine's verdict on a call, derived from the conversation — and it decides whether anything is scheduled to happen next.
Suppression	Suppression is a standing block on contacting an address or number. It outranks every other reason to send, and its origin decides whether it can be lifted.
DNC	Do not contact is the strongest block a workspace can set on a person: every channel, no exceptions, and not something the Connect Assistant may clear.
Entitlement	An entitlement records what a workspace's subscription permits: which features it reaches and what daily volumes it may use, as two separate questions.
Allowance	An allowance is what remains of a period's permitted volume. Some are refused at the limit, some are ceilings on what may exist, and one is only counted.
Workspace kernel	The layer that filters every database query by workspace, why it is not the same thing as row-level security, and what an empty workspace stamp does to a record.
Customer-safe	The allowlist that decides which API paths a customer session may call, how it differs from the rewrite that happens in the browser, and what its 403 means.

Comparisons#

Page	What it covers
Connect and a CRM	Connect keeps people, companies and deals as a by-product of work it does; a CRM keeps them as the thing itself. Which record belongs where.
Connect and a chatbot	A chatbot answers the person in front of it. Connect works a business's whole mail across channels, remembers, acts, and records who decided what.
Connect and a helpdesk	A helpdesk organises work into tickets and queues. Connect tries to finish the work before a queue exists, and keeps cases for what it cannot.
Connect and workflow automation	Automation runs a path you drew in advance. Connect decides what a message needs. Where each belongs, and what happens when you pick the wrong one.
Connect and a call centre	What answering every call the same way is worth, what it costs, and the three things on a live Connect line that a call centre still does and it does not.
Connect and email marketing tools	A broadcast tool sends one message to a list that agreed to hear from you. Connect writes one message to one person. The consent models are not the same.
Connect and sales engagement tools	Sequence tools optimise cadence and volume. Connect optimises whether the message should be sent at all, and refuses to guess an address or a price.
Digital employee and AI agent	An AI agent is a technical pattern. A Digital Business Employee is a commitment to permanence, responsibility and oversight. Confusing them costs money.
Agent and assistant	The engine starts work on its own and is governed by autonomy. The Connect Assistant answers a person and has narrower rights than they do.
Memory and context window	A context window is what the model can see during one call. Memory is what survives it. Enlarging the first will never produce the second.
Knowledge and memory	Knowledge is what you told Connect is true about your business. Memory is what it worked out about a person. Putting a fact in the wrong one has consequences.
Rules and instructions	A rule is enforced in code whatever the model concludes. An instruction is text the model is asked to follow. One prevents; the other, at best, detects.
MCP and A2A	MCP hands tools and data to a model. A2A lets one agent give another agent a task. Connect publishes both, and they answer different questions.
MCP and a plain API	MCP exists so a model can discover what it may call at runtime. An HTTP API exists so your code can call exactly what it already knows it wants.
Realtime and turn-based voice	Two voice engines with different physics: one speaks straight from the model, the other produces a sentence code can inspect before the caller hears it.
Gmail API and IMAP	Two ways to connect a mailbox to Connect. One knows about labels and history; the other works with any mail server in the world. What each costs you.
Autonomy and approval	Autonomy is the standing rule for what Connect may do unasked. An approval is one held action waiting on a person. Changing one does not do the other's job.
llms.txt and a sitemap	A sitemap is a protocol search engines actually read. llms.txt is a community proposal. Publishing one instead of the other costs you discovery.
Structured data and content	Markup describes a page; it is not a second page. When the two disagree the markup is the thing that is wrong, and the cost is not theoretical.
Operator and customer, as a design idea	One codebase serving the platform operator and its customers: what the pattern costs on every change, and the class of defect it makes impossible.
Evidence and inference	Something observed and something concluded are not the same claim. Where Connect draws the line, and what each kind of statement lets you act on.
Drafting and sending	Writing a reply and sending it are two acts with very different consequences. Why the approval gate sits exactly between them and nowhere else.
A record and a transcript	A transcript says what was said once. A record says what is true across everything that happened. Each answers questions the other cannot.
Scheduled work and triggered work	Work that starts because something happened, and work that starts because a time arrived. Two clocks in one system, and what happens where they meet.
Suppression and blocking	Two ways of telling Connect not to contact somebody, enforced in different places. Which one you need depends on whether you mean an address or a relationship.
Workspace and account	Your account is who you are; a workspace is where the business lives. Which one owns what, and what happens when a person and a business part company.
Public documentation and private help	Some of what Connect knows is written for anybody to read, and some can only be answered inside your workspace. The line between them, and why it is drawn there.