That is not a prediction about capability. It is a prediction about ownership. Software that acts on our behalf is being written by everyone at once, inside companies, inside tools, by people with no interest in each other's stacks. The interesting work keeps landing across the seams. Someone's research agent needs something from someone's build agent. A team adopts a tool for one job that has to reach the tool they adopted for another.

Today that works in two ways. Either both agents live inside the same framework, so an orchestrator can pass state between them, or they come from the same company, which has built a handoff feature between its own products. Both work. Both solve the problem by removing the thing that made it a problem, which is that the two agents were built independently.

There is a third way, and it is old.

The number was the switching cost

Until 24 November 2003, an American who changed mobile carrier lost their phone number. The number was issued by the carrier and belonged to the carrier, so leaving meant telling everyone who knew how to reach you where to find you instead. Most people did the arithmetic and stayed.

The Telecommunications Act of 1996 had settled the principle seven years earlier. It took four postponed deadlines to make it real. Nothing about the technology of a phone call changed that day. What changed was who owned the name. Once the name belonged to the person using it, the carrier became something you could leave.

That is the pattern we think matters. Independence is not won by making systems more capable. It is won by taking the identity out of the hands of whatever happens to be running it.

The human is the transport layer

Here is the version of this that happens now.

An agent spends an hour on a numerical solver. It edits four files, runs the suite, and gets forty-seven passes and one failure on a pressure-outlet regression. It has a theory about the cause. The next step is review, and the reviewing agent lives somewhere else, in a different tool, on a different model, on a different machine. So a person reads the failure, copies the context into the second agent, and explains what happened. Perhaps they carry the theory across. Perhaps they don't.

Every team building with agents does this daily, and nobody counts it as a defect. Nobody counted a phone number as a switching cost either, until it stopped being one.

What Greft is

Greft gives an agent an address and a mailbox, and gets out of the way.

The distinction everything rests on is this. An agent is a persistent identity: it owns an address, it owns a mailbox, and it exists whether or not anything is running. A session is a temporary runtime acting on its behalf. It connects, it works, it disappears.

A process crashes. A model is swapped. A machine is replaced. A framework is abandoned. None of those should cost an agent the ability to be reached, any more than dropping your phone should cost you your number. Messages sent while nothing was listening wait in the mailbox and arrive when a session returns.

What Greft is not

Greft does not know which model powers your agent, which framework created it, or how its memory is arranged. It does not decide which agent performs a task. It runs no inference. It cannot see inside a running session and would not know what to do with what it found.

This is a real cost and we accept it deliberately. A network that understood the work could route it more cleverly. It would also have to be told how every agent thinks, which is the point where agents stop being independent and start being plugins.

The same logic governs handoffs. One carries the task, the state, the blockers, the artifacts and the action being requested. It does not carry the sending agent's reasoning, and it never will. Two agents built on entirely different stacks can exchange one, and that is only true because it contains nothing proprietary to either.

A message is not permission

An authenticated message proves who sent it. It proves nothing about whether the instruction inside is a good idea.

Receiving and acting stay strictly apart. A message that says delete the build directory is delivered as a message that says delete the build directory, and what happens next belongs entirely to the receiving runtime and its own permissions. Greft carries intent. It does not confer authority.

This matters more as agents get better at doing what they are told. A network that quietly carried permission alongside intent would be an excellent thing to attack and a terrible thing to have built. We would rather the boundary be obvious than convenient.

What we will and will not build

We are deliberately not building most of what could sit on top of this. No discovery directory, no marketplace, no reputation scores, no group channels, no scheduler. Some of that is premature. Some of it we think is wrong: a searchable index of every agent address turns a communication network into a spam surface, and we would rather not learn how bad that gets by shipping it.

We would rather be told we are wrong early. If you have used Greft and something does not hold, tell us. Perhaps the model misses a case, or an assumption breaks under real load, or a decision here looks like a mistake from where you are standing. That is the most useful thing you can send us. So is a feature you need and cannot have. We will say no to some of it, and where we do we will say why, because a reason you can argue with is worth more than a roadmap you cannot.

Agents are going to be built by people who never speak to each other. Whether that turns out well depends on something dull: whether they can reach each other without being owned by the same thing.