A primitive is a treaty.

Somewhere right now, a very good engineer is redesigning the support ticket.

Not fixing one. Redesigning the concept — because now that an agent can answer in four seconds, a queue with a status field and an assignee looks like a fossil from an era of scarce humans. And they are right about the fossil part. That is exactly what makes it dangerous.

The same thing is happening this year to the git repository, the calendar event, the CRM record, the purchase order, the code review, the message in a channel. Every one of them is being redesigned by someone clever, on the entirely reasonable grounds that they were all built for humans and the humans are about to stop being the bottleneck.

We have done this four times. Mainframe to personal computer, personal computer to the internet, internet to mobile. Each wave produced a cohort of companies whose real product was a rewritten primitive, and almost all of them lost to the boring version that was already installed.

I think this time the rewrite is not merely risky. I think it is unnecessary — and the reason why is worth more than the conclusion.

The boring version does not win because it is better. It usually isn’t.

A support ticket is a bad data structure. It has a status field encoding a workflow nobody follows, a priority nobody sets honestly, one assignee for something nine people touched, and a free-text body where all the actual information lives, unqueryable. Sit down today with no history and you would design something better inside an hour.

You would also never get anyone to use it.

Because the value of the ticket was never in the schema. It is that everybody has already agreed what one is. Service level agreements are written against it. Commercial contracts reference it. Auditors ask for the export. Every support hire on earth arrives already knowing what it means. Every helpdesk, every integration, every reporting tool speaks it without being told. Procurement has a line for it.

That is not a data model. That is a treaty — a shared definition already signed by a very large number of parties, most of whom you will never meet and could not convene if you tried.

Every durable primitive is like this. A git repository is a treaty about what counts as the state of the code and who says so. An invoice is a treaty about money being owed, honoured by people who have never spoken, enforceable in court. A message in a channel is a treaty about who said what, to whom, in what order. Their strength has almost nothing to do with their elegance and almost everything to do with how many parties have stopped arguing about them.

When you set out to replace a primitive, the engineering estimate is honest and almost completely irrelevant.

Building a better ticket is a fortnight. Here is the rest of the bill. Your customer’s auditor has to accept the new artefact. Their legal team has to agree the SLA still means something. The tool on the other end of the integration has to learn a noun it has never heard. Every person they hire has to be trained out of the thing they already knew, forever, as a permanent onboarding tax. Every report anyone built has to be rebuilt. And each of those parties has to do this work for your benefit, on their own budget, having asked for none of it.

None of that is engineering. All of it is renegotiation, and the counterparties have no particular reason to come to the table.

So the real price of a new primitive is roughly the number of parties who have to re-sign, multiplied by how little each of them cares. It bears no relationship to how good your version is, which is why ours is better has essentially never been sufficient, and why the graveyard is full of primitives that were correct.

There is a reason clever people keep making this mistake, and it is that they are looking at something genuinely real.

Most of what we call a primitive is two things welded together: a record of a fact, and a scheme for rationing a scarce human.

In a support ticket, the fact is: a customer asked us something, we owe them an answer, here is what we promised, here is whether we kept it. The rationing is everything else. The queue. The assignee. The priority tier. Business hours. The escalation ladder. The tier-one to tier-two handoff. All of it exists because human attention was scarce and had to be allocated, and none of it is about support. It is about supply.

AI dissolves the rationing, completely, and it should. If you can answer everything at once you do not need a queue, and the tiering was always a tax the customer paid so that you could staff cheaply.

The fact survives untouched. Somebody asked, we owed them, we delivered or we did not. That is true whether the answer came from a person in Manila, one model, or four hundred agents. It will be true in 2040. It is the primitive, and it was never the part that got obsolete.

The error is to watch the left column dissolve and conclude that the right column died with it. It didn’t. You are deleting a queue. You are not deleting a record — and the record is the part with the treaty attached.

Version control is the cleanest example of getting this right by accident. A commit is a fact: this is what the code was at this moment, content-addressed, and here is who says so. The rationing built around it — branch protection, the two-approver rule, the release train, the freeze — is scarcity management, and every team running agents is tearing it up and rebuilding it right now. Correctly. Nobody sensible is rewriting the commit. Git was designed by someone paranoid about a large number of actors he could not personally vouch for, which turns out to describe a fleet of agents exactly.

Now the part that would make this note too comfortable if I left it out. Something does break.

Every primitive carries an assumed tempo, absorbed silently from the only writer it ever had. A channel assumes a few hundred messages a day, because that is what people can produce. A ticket queue assumes triage latency in hours. A code review assumes somebody reads it. A CRM assumes a record is touched a handful of times by a person who remembers the last conversation.

Point agents at any of them and you exceed the assumption by three orders of magnitude inside a week. The channel becomes unreadable. The queue becomes meaningless. The review gets rubber-stamped. The CRM fills with updates that are all true and collectively worthless.

That is real, and it looks exactly like the primitive failing. It isn’t. The noun is fine. What failed was a default — a number baked in when the only writer was a person.

Defaults are cheap. They are a rate limit, a filter, a summarisation step, a convention, a separate channel for the machines. Nouns are treaties. The engineering instinct is to conclude that this does not work at agent scale so we need a new model, and the correct conclusion is almost always that this needs a different default and somewhere sensible to put the volume.

Underneath both of those is the thing that makes this wave different in kind. Every previous shift replaced the floor. New machine, new form factor, new distribution — so everything standing on the floor had to be rebuilt, and the primitives got rewritten as a side effect of the substrate moving. AI does not move the floor. It arrives on top, and changes who does the work rather than what the work is recorded as.

That is the whole argument, structurally. A rewrite of the primitives was compulsory in 1984 and 1995 and 2008 because the ground under them was being replaced. It is optional now. And optional rewrites of treaties do not get signed.

The strongest objection is that agreement is not the same as merit. Everyone agreeing is also how we ended up with QWERTY, imperial units and the support ticket. If a primitive is bad, someone should fix it. Why is that not simply the work?

It is honourable work. Here is the thirty-year record of doing it.

In the late 1980s the microkernel was the correct architecture and everyone serious knew it. Small trusted core, drivers and filesystems out in user space, failures contained instead of fatal. The monolithic kernel was the compromise you tolerated. Then Linux — a monolith, explicitly the wrong design, argued into the ground by people with better degrees — won so completely that it is now the substrate of the entire industry. Not because Torvalds was right about architecture. Because the interface was already agreed, everything was already written against it, and the better design’s advantage was smaller than the cost of moving.

IPv6 is the same story with the timeline made explicit. Specified in 1998. Unambiguously better. Genuinely necessary — we ran out of addresses in 2011. It is 2026 and it still has not finished replacing a scheme everyone agrees is exhausted. Nothing about that delay is technical.

So: correctness does not beat agreement. It has to outlast it. And outlasting an agreement takes about a generation, which is a perfectly good thing to spend your life on and a very bad thing to put on a roadmap.

None of this says never build one. New primitives do arrive. They just arrive far more rarely than each wave believes, and there is a test for it.

Does the new layer create a fact that no existing primitive has a field for? Not a fact expressed awkwardly. A fact with nowhere to go at all. That bar is high, because most new technology produces new ways to do old things.

Mobile passes it about twice. Where I am, continuously, became the location fix — and everything from the ride to the geofence is downstream of that one new fact. Reach a person who is not at a desk became the push notification. Everything else mobile is credited with inventing was a new client for a primitive that already existed; email is still a message with a sender, a subject and a thread. The internet earned the URL, and the checkout: a stranger transacting with no prior relationship. Four decades of upheaval, a handful of genuinely new nouns.

By that test, agents create four facts with nowhere to live.

All four are boring infrastructure, which is a good sign. Real primitives usually are — the URL and the invoice are boring. Notice too what is not on the list: the ticket, the repository, the channel, the calendar, the record of a customer. Those are the ones everybody is rewriting, and not one of them contains a fact that agents made new.

I want people building those four, and I think they will take longer than their builders expect, for reasons that have nothing to do with the engineering.

A primitive is not adopted. It is agreed. Agreement moves at the speed of the people who have to agree, and those people mostly do not change their minds. They get replaced.

Chat is the clearest case, and it is funnier than it looks. IRC, 1988: a channel, messages in order, presence, a mention, a direct message. Slack, 2013: a channel, messages in order, presence, a mention, a direct message. Discord, and whatever the next one is: the same. Three generations of people have adopted a revolutionary new way to talk at work, and the primitive underneath has not moved in thirty-eight years. What changed each time was the client, the business model, and above all who was arriving in the workforce and wanted a room of their own.

It is worth being precise about the exception people reach for. Teams beat Slack on seats, and that was not a generational preference at all — it arrived inside a tenant that had already paid, which is a different argument entirely. Procurement moved. The primitive did not. It never does.

Which is the actual reason to welcome the people building agent-native rails rather than betting the quarter on them. They are not wrong. They are early, and early on a treaty means waiting for the cohort that will sign it. Somebody has to be there when that cohort turns up.

The pull here is strong and it is not stupid. Rewriting a primitive feels like foundational work. It is legible, it is architecturally satisfying, agents make it look nearly free, and it produces something you can draw on a whiteboard. It is also the most seductive version of the mistake in the T-shaped note — enormous effort, spent reproducing something the world already had and had already agreed on.

We ship into Slack for exactly this reason. Not because Slack is well designed for what we do — a channel is a poor database and its threading fights us most weeks — but because a message in a channel is a treaty every one of our customers has already signed. It costs them nothing to start, which is the only adoption number that has ever mattered. The part we own is the part that is not universal: the method inside one specific firm, which is the only thing that compounds.

The primitives are free, installed, and already agreed. Every hour spent replacing one is an hour not spent on the single part of your product that nobody signed for you.