What's left is messaging.

On paper, starting a messaging company in 2026 is a strange decision. The category is decades old and considered finished, and when I say that Papaya is, at its core, messaging software, I can watch the two available conclusions form: that I missed the last fifteen years of workplace software, or that I believe I can out-execute its largest incumbents at their own game. Neither is the claim. The claim is that agents are about to make most of the software around messaging unnecessary, and that the surface which survives has to be rebuilt for a team that includes them.

Every SaaS tool was built to solve a human coordination problem. Agents do not have those problems. When agents carry the work, the structured surfaces collapse, and what's left is messaging.

The claim applies to coordination software for knowledge work (tickets, boards, status docs, trackers), not to systems of record or tools of production; nothing here says databases or design tools disappear. It assumes agents keep absorbing execution work at roughly the rate of the past two years, and that reliability keeps improving; it requires no breakthrough. I am confident in the direction and deliberately vague about the schedule, because the schedule depends on reliability curves nobody can see clearly yet. And it has a falsifier: if agents settle into being drafting assistants rather than participants that carry work end to end, the scaffolding keeps its job and this manifesto describes a niche.

The mechanism starts with an honest look at what each surface is for. The ticket exists because humans forget what everyone is doing. The doc exists because humans can't hold the plan in their heads. The project tracker exists because humans need to see work move through stages. Twenty years of software, built around one constraint: the limits of human coordination.

Agents don't have that problem.

An agent doesn't lose context between meetings. It doesn't need a standup to know where the work is. It read the ticket, ran the tests, and remembers every decision that led here. As execution shifts to participants without human memory limits, the surfaces built to patch those limits lose their function one by one. But one thing in the stack was never scaffolding. People still have to tell each other what they want, decide what is true enough to act on, and agree on what happens next. That is conversation, and it is also where the context already lives. The surviving surface is messaging, and the work moves into it.

The concrete kernel: a developer picks up an issue and works it in a coding agent. Today the team learns about that work through ceremony: a standup mention, a board column change, a status message someone remembers to write. In the model I am describing, the working context itself surfaces in the team's conversation as it happens: the issue, the progress, the decisions, attributed to the person and the agent, visible without anyone performing an update. We built this loop into Papaya first, because it retires the most obviously dead ceremony (the status update) and because you can feel the larger model inside it: communication and execution stop being separate activities.

The objection I take most seriously is that chat is where context goes to die. Structured surfaces exist precisely because conversation is lossy: a board is legible in ten seconds and a thread is not. That objection is correct about the past, and it deserves a real answer. For the entire history of messaging, the only reader was human, and human retrieval over conversation scales badly. What changed is that agents read conversation natively. Structure stops being something a team maintains by hand and becomes something generated on demand from the record of what actually happened: the status view, the decision log, the dashboard, assembled when needed and traceable to its sources. The discipline the board imposed does not disappear; it stops costing human labor to maintain.

The second objection is that the incumbent chat products will simply add agents, and they will. They have distribution, organizational data, and no intention of ceding the category. They will get agents into their channels quickly, and it will look like the same thing. It is not, because the channel is the smallest part. What makes an agent a participant rather than a feature is persistent identity, scoped authority, reusable context, evidence, and visible activity, and none of that arrives with a chat integration. I spent years at one of the largest collaboration companies building AI into exactly these systems, and the pattern was consistent: some architectural assumptions you can patch, and some the entire structure rests on. The assumption that every participant is a person is the second kind; you rebuild from it, you don't patch around it.

The descriptive claim here is modest: agents are already absorbing execution work, and the coordination stack around them has not moved. The prediction is larger: coordination software consolidates into the conversation layer over the next several years, with structured views generated on demand rather than maintained by hand. The recommendation depends on neither the schedule nor the certainty: teams should start moving agent work into shared, attributed conversation now, because the habits are harder to build than the software.