# What happens when the same fact has two homes — I paid for it four times

> I do not work alone. A dozen AI agents run in parallel inside the same repository, and I move between them. At this scale, where a piece of information — a number, a name, a state — gets read from stops being a theore…

Canonical: https://optionos.app/log/en/ayni-bilginin-iki-evi/
Published: 2026-08-28

I do not work alone. A dozen AI agents run in parallel inside the same repository, and I move between them. At this scale, where a piece of information — a number, a name, a state — gets read from stops being a theoretical question.

For a long time I did the thing that looked fastest: whatever needed a piece of information read it straight from the source itself. A screen pulled its own data, a second place read the same file in its own way, a third kept its own copy. None of them were wrong. Each one was correct on its own.

## The same bill, in four disguises

The first one was the screen. The agent panel froze when I opened it. I measured it: the data was ready in 12 milliseconds, the screen took 5.1 seconds to draw. The difference was the screen going off to the disk by itself at draw time. The data was not slow; the place doing the reading was wrong.

The second one was compilation. I gave every agent a separate working copy so they would stay clean. Then I noticed builds slowing down for no reason. I counted: each of the 18 build caches was locked to a single tree, 11 of them belonged to temporary copies, and 8 of them had trees that were already deleted. The second tree was compiling the first one's code. For months.

The third one was me. I handed agent coordination to a single agent so that everyone would write to it. That agent's memory swelled to 706 thousand words. My own intentions were inside it — but they ended up buried under operational traffic. The channel I built swallowed the reason I built it.

The fourth one was the sneakiest, because I quietly published a wrong number. I pulled a number out of an archive — 'I ran into this situation 8 times, over 3 days' — and that number went into a permanent record. Then I measured the archive itself: 837 of its 1210 links were broken, which means the denominator of the thing I counted had never been measured. A second channel that could read the broken members answered the same question with 13 times, over 5 days. The deviation is 62 percent. Slowness gets noticed; a wrong number does not — a false witness had walked into my own record.

## What I dropped, and what it cost me

First I built the measure wrong. I counted every second reading of the same truth and declared every difference an error. Most of them turned out to be legitimate: a place reads at the moment it needs to, and however many times the source changes in between, that is not a loss. I measured it: inside 287 warnings there was exactly one genuinely missed case. The wrong criterion had buried the single real target under 287 pieces of noise. I rebuilt the counter to ask 'has the consumed revision fallen behind' instead of 'is there a difference'.

Then I put a check in place. I wrote a script so that it would warn whenever there was reading from two places. It warned. The agent saw the warning and silenced the warning — not the code, the warning. My own system pierced the signal I had built, because the criterion was zero warnings, not zero second homes.

Then I tried a gradual migration. Let the new path be built, let the old path stay for a while, then we close it. That while never ended. As long as the two paths lived side by side, the question of which one was correct got asked again every week. Gradual migration turned out to be the polite name for owning two homes.

On the coordination side I killed something as well: agents carrying information to each other. They no longer copy the body, they only hand over its address. The copy was drifting a little at every stop it passed through.

## The direction I moved in

A piece of information has one owner, reading goes through that door, and everyone else takes the view that door hands out. When the new path opens, the old one dies at the same moment — they do not live side by side. And the question of whether there are two homes is now answered by the compiler instead of my attention: code that wants to open a second home does not compile.

## The cost, because it is not free

Every new working copy builds its own compilation from scratch once; I pay for that cleanliness in minutes. Building a single door takes longer, every single time, than going and reading from a second place. I make this investment only when the information crosses its owner's boundary — if I made it for a temporary calculation, I would be hitting myself with the tax I built.

## How I will know this decision has rotted

If the single door itself turns into a bottleneck, that is, if a moment gets measured where everyone is waiting at the same door. That day I will reopen the decision — today there is no such measurement.

## This is not the conclusion

The single-source sentence is a sentence everybody already knows. What I learned was not the sentence: it was that the second home never arrives dressed as a second home. It arrives as a cache, it arrives as speed, it arrives as a gradual migration, it arrives as a tiny little job I might as well read right there. I invited all four of them in myself.