Someone forwards you a message, four people reply, and the subject collects two Re: prefixes and an [External] tag. What your client shows as one thread is a set of messages it has decided belong together, and it makes that decision from headers on each message rather than from anything the mailbox keeps.
What a thread is
A thread is a group of messages that a mail client treats as one conversation. Your mailbox holds messages as a flat list in a folder, and each message carries its own headers; the client reads those headers when it draws the list, works out which message points at which, and builds the tree you see.
Nothing is saved as the thread itself. There is no container to move, rename or delete, which is why a thread misbehaves in ways the messages inside it do not.
Why moving one message does not move the thread
A folder is a container, and a thread is a shape a client draws from the messages it has in front of it.
RFC 5256, which defines the IMAP threading extensions that mail servers and clients implement, runs its algorithm over the messages a search returns. When the algorithm meets a message id it cannot find, it creates a placeholder for that id rather than treating the conversation as broken.
That is what you are looking at when a message leaves the view. Archive one reply, or drag it to a folder, and the client draws the thread from what is left. The other messages have not moved and nothing has been lost, but the tree in front of you is missing a branch, and putting the message back brings the branch back.
Outlook keeps the same kind of record for itself. Each message carries a conversation index, and Microsoft’s protocol documentation describes that property as the relative position of the message within a conversation thread, with a GUID generated for each new thread. The grouping is stored on the messages themselves.
The three headers that build a thread
RFC 5322, the standard for the format of an internet message, names the fields that carry the structure:
| Header | Who sets it | What it holds |
|---|---|---|
Message-ID |
The system that sends the message | One unique id for that message, written in angle brackets, such as <[email protected]> |
In-Reply-To |
The client that sends the reply | The Message-ID of the message being replied to |
References |
The client that sends the reply | Every Message-ID in the chain, oldest first |
A reply’s References field is built by taking the parent’s References and appending the parent’s Message-ID, so the field grows by one entry per message and reads as a path from the first message to the last. The RFC notes that some implementations walk backwards through that field to find the parent of each message, and advises against constructing a reply with more than one parent because of it.
The chain is what a client trusts. The subject matters only when the chain runs out.
The subject line is the fallback
When a message arrives with no usable In-Reply-To or References, the client still has to file it, so it compares subjects. RFC 5256 defines that comparison: strip the reply and forward prefixes, strip a bracketed prefix, strip a trailing (fwd), then compare what is left. The result is the base subject, and the standard requires servers and disconnected clients to compute it in exactly the same way.
That fallback explains two things people notice without knowing why. A reply that arrives with no Re: still lands in the thread, because the prefix was never part of the comparison. An edited subject, or a client that adds one, can start a second thread from the same conversation.
Gmail states the split in its own help: a conversation breaks off when the subject line changes, or when it reaches more than 100 messages.
Why two conversations merge into one
Merging is not a fault in your client. RFC 5256’s algorithm has a step whose whole job is to merge threads that share a base subject, so a client with nothing better to go on will treat two conversations called “Invoice question” as one.
The usual cause is a reused message. Someone opens an old thread, hits reply, and changes the subject to start something new. The client builds the new message from the one being replied to, so it copies the References field across, and the receiving client follows those headers before it reads the subject at all. RFC 5256 says it plainly in its security notes: a message with false References: header data will cause a thread to be incorporated into another thread.
Gmail merges automated mail on a looser rule again. Its help says messages are grouped into one conversation when they share recipients, senders or subjects with an earlier message, carry a reference header with the same ids, and were sent within a week of it. A notification system that mails the same subject from the same address collapses those messages into one conversation whatever the headers say.
What breaks threading in practice
Four failures account for most of it.
| What happens | Why the chain breaks | What you see |
|---|---|---|
| A mailing list or group rewrites the message | List software adds its own fields, and RFC 2919 says the List-Id field must only be generated by mailing list software. It often adds a bracketed tag on the subject as well, which the base-subject rules strip |
Replies land outside the original thread, or two list threads merge |
| A forward goes out as a new message | The forward gets a new Message-ID and, sent as a new message, no reference to the original |
The client falls back to the subject, so the forward joins whatever else shares it |
| A support tool emails every reply as a fresh message | Each notification carries a new Message-ID, and if it does not reference the customer’s message the subject is the only link |
The conversation shows up as a row of separate one-message threads |
| A client keeps only the most recent references | RFC 5256 notes that the References field may have been truncated by a mail client, and treats a message that already has a parent as a trimmed chain |
The chain goes shallow, and matching falls back to the subject |
The first three leave you holding two messages with nothing linking them. The fourth is invisible from the outside, because the headers on your copy of a message are not always the headers on the recipient’s copy.
Why a split thread costs more on a shared address
One person with one mailbox can live with a split thread. Four people answering support@ cannot, because on a shared address the thread is the record of what the customer has been told. A split hides half of that record from whoever opens the next message, so two people answer the same question, and the customer gets the same reply twice or gets nothing at all.
Chirp keeps the mailbox as the source of record and puts the same address in front of the team, so a reply goes out through that mailbox rather than around it. Each inbox has its own address, signature and access list, which the server checks on every read, so the conversation a teammate opens is the one the customer is already in. What is a shared inbox covers that arrangement, and what separates it from a shared mailbox or a distribution list.
If a thread that keeps splitting has pushed you toward comparing tools, shared inbox vs help desk is the next decision.
FAQ
What is email threading?
Threading is a client’s work of deciding which messages belong to one conversation and drawing them as a group. It reads the Message-ID, In-Reply-To and References fields to do it, and falls back to the subject when those are missing or do not connect.
Why did my email thread split in two?
Usually the subject line changed, or a message arrived without a usable reference to the one before it. A client that trims the References chain, a mailing list that rewrites the message, and a forward sent as a new message all produce the same result.
How do I stop emails from threading?
If you are sending, start a new message with its own subject instead of replying to an old one, so it carries no reference to the earlier conversation. Gmail’s help gives the same advice for automated mail, with a unique reference header value as the alternative, and it covers turning conversation view off in settings.
Do all email clients thread the same way?
No. Gmail rebuilds conversations from the messages in the mailbox and breaks one off when the subject changes. Outlook keeps a conversation index on each message, with a new GUID for each new thread. Both fall back to the subject when the reference headers do not connect two messages.
Is an email thread the same as an email chain?
They describe the same set of messages, and clients use the words interchangeably. The standards use thread: RFC 5322 says the References field may be used to identify a thread of conversation.
Next step
A thread is a recipient list that builds itself, since everyone who replies stays on it. What CC and BCC mean in email covers who can see what on that list, and what changes when the address behind it is one that four people answer from.
