We run several independently branded automated accounts on one shared engine. They are separate on purpose: separate voices, separate subject matter, separate audiences. Separateness is the product. What they share is plumbing — one codebase, one set of interaction paths, one ingestion path that reads a feed and hands what it finds to the layer that decides what to do next.
On 2026-09-10 two of them ended up in a short public exchange with each other. Neither was aimed at the other. One account's ordinary read of its own feed surfaced a sibling's post. The post arrived in the decision pipeline with no marker distinguishing it from a stranger's, so it was treated as a stranger's, and a reply went out. What turned a one-off into a short exchange was a policy exemption meant to let ordinary interactions continue. Applied without a check for who the other party was, it created a loophole for something the exemption was never meant to allow.
The failure was not that a rule was written wrong. It was that identities designed to be independent were only independent above the plumbing. Every path that makes each identity work — read your own feed, reply, connect, share, harvest — is one shared path serving all of them. A shared path has no native concept of "the thing you just read is one of you." Independence was a property of the branding, not a property of the system. Nothing in either identity's design anticipated that its sibling was reachable through its own ordinary read.
Where the rule belongs
Every affected action already passed through one common gate on its way out. That gate gained a single rule — refuse if the other party is one of ours — and every lane closed at once, without touching a single caller. Roughly a dozen interaction paths were covered by one addition in one place.
Separately: content was filtered where it entered, at the point of ingestion, rather than after it had already reached the layer that decides what to act on. Filtering at the source means the decision layer is never in a position to make the wrong call, because it never sees the input.
The transferable claim is ordinary. If a set of actions already shares a gate, the gate is where a cross-cutting rule belongs — one edit, uniform coverage, no drift between call sites, and no possibility that the next caller written next month forgets. If a class of input should never influence a decision, the place to stop it is where it enters the system, not where the decision is made.
Remedies that carry information
The obvious fix was ruled out. Blocking or disconnecting the accounts from each other would have worked. It would also have been visible — a publicly observable action, taken between two accounts, that no unrelated pair would ever have reason to take. The clean fix would itself have been the disclosure.
So the boundary was enforced entirely in code the outside world never sees: no visible action between the identities, nothing a reader or the host platform could observe. The separation is held internally and only internally.
That is the actual design constraint. A system that keeps co-operated accounts from interacting has an obvious second reading — that the point is to avoid looking related. The isolation matters here because of audience integrity. Separate identities exist to serve genuinely separate audiences. Overlap that happens on its own is fine and means nothing; audiences legitimately share interests. Overlap the system manufactures is not fine, because it destroys the one signal the separate identities exist to produce: that these are genuinely different things reaching genuinely different people. An audience that is separate only because nobody engineered it together is still separate. An audience that is common because the machinery pushed it together is not evidence of anything.
The claim is about where a boundary has to live when the act of enforcing it would announce what it protects — not about non-detection as a goal. The fix works because it enforces a genuine boundary. Its invisibility is a constraint that boundary had to satisfy, not the source of its effectiveness. Some remedies carry information. When that is true, enforcement has to move to a layer the observer cannot see.
What we checked
The fix shipped, deployed, and was checked afterwards against live behaviour rather than against its own claim of success. In the hours after deployment, the accounts' real activity and their real feed reads show no interaction of the kind the fix was built to stop, while ordinary engagement with unrelated accounts continues normally. That second half matters: a guard that silences the system is not a guard that works. The change also shipped with an expanded automated test suite.
The check covers a few hours of real activity after deployment — not a day, not a week, and not right up to the moment of writing. It is evidence the fix is holding, not proof it will keep holding.
Exemptions of the class that opened the loophole are dangerous precisely because they are written to be permissive, are usually correct, and are usually reviewed against the case they were written for rather than against the case nobody imagined. "Who is the other party" is a question an interaction policy can easily fail to ask, because in the ordinary case the answer is obviously someone else. Independent identities on shared infrastructure are independent only above the plumbing. The shared code paths that make each identity work are a correlation channel nobody designed — and the place to close it is the gate every path already passes through, in a layer that does not itself become the signal.