Tlon Messenger · Product Lead

I have led product development at Tlon for five years, through a full rewrite, a team cut in half, a long stretch of instability, and a pivot to agents. We build on a bet that decentralized networks can carry real conversation, with no middlemen and no advertisers.

Tlon's product is a personal server: each user runs their own real-time messaging service on a decentralized network. Our native smartphone clients talk to that server and handle push notifications, app badges, and background sync. Users can let Tlon host the server in a single-tenant environment, or run it themselves and connect with the same apps.

The Groups 2.0 rewrite

In early 2022 we rewrote the social product that had drawn a crowd to the decentralized web during the 2020 pandemic. The rewrite replaced both the back-end architecture and the client, and added the table-stakes features Discord and Slack users expect. The architecture change meant the migration would take major groups offline and could break software across the network.

We rolled out in three stages: a developer alpha in July 2022, so third-party builders could port their applications; a public beta in November, so early adopters could report back; and an over-the-air update to the entire live network that December. The team worked the release in shifts across time zones, from Australia to Europe to both US coasts.

The rush cost our users data. We had a naive picture of what user data actually looked like across the network, and the migration scripts missed edge cases: dropped inserts, dead subscriptions, crash loops.

We spent months repairing the damage and longer rebuilding the trust. The lesson was cheap to state and expensive to learn: know the shape of your users' data before you migrate it.

A long winter of jank and churn

Commercial product quality on a peer-to-peer back end met its limits fast: joining a group loaded the entire unpaginated backlog, connections dropped constantly, and events failed to propagate through group hosts. Our team shrank from twelve to six.

Our sprints also outran our manual test coverage. Every release added surface area, the new bugs ate the time we would have spent testing, and we shipped the next feature instead. The loop tightened on itself for the better part of two years.

Through 2023 and early 2024 we treated the loop as a speed problem. We launched mobile apps, in-app signup, role-based permissions, rich media embeds, and a Contacts system. We answered complaints, checked roadmap items, and hit OKRs.

The scaling work told the real story. A mid-2023 refactor to separate publisher and subscriber roles was scoped at three weeks; we shelved it again and again to ship the next feature, and it ran for months. The v5 and v6 mobile releases through mid-2024 went more smoothly, but we were still stacking weight on a foundation that could not hold it.

Finally, a modicum of stability

By mid-2025 the recurring bugs read as symptoms. Missing sequence numbers, full-history loads, and ad-hoc push notifications all traced back to the 2022 architecture, where each flaw fed the next. In August 2025 we stopped feature work.

First we built the end-to-end testing framework we had skipped for three years. Nothing else made releases predictable.

Then we root-caused every issue instead of patching it. That cost us time on each bug and stopped the same bugs from coming back.

From September to December 2025, releases v7.1.0 through v8.1.0 shipped stable push notifications, app icon badging, group templates, privacy and safety controls, and group management, none of it destabilizing:

• Push notification reliability hit 99%
• Monthly bug count dropped by 75%
• Releases moved from daily hotfixes to a biweekly or monthly cadence

Blocking, role management, and join requests each shipped in a single release rather than over months. Stuck channels and navigation loops stopped happening.

Six people can outbuild a larger team, but never by moving faster. What it took was stopping.

The pivot to agentic messaging

In January 2026, agents arrived at Tlon the way most real product directions do: sideways. A teammate built a working chatbot over a weekend that listened for mentions in channels and replied on its own; an MCP server I had written for Groups could already read messages and manage contacts in natural language.

Within two weeks our integration was accepted upstream into OpenClaw, an open-source agent harness, as an official channel type alongside Telegram and Matrix. The team was split on whether any of this was a growth vector or a distraction.

The case for it was that agents made our architecture legible. For years we had described the personal server as the "computer underneath" the messenger and struggled to explain why that mattered.

A personal agent explains it instantly: it runs on a server you own, remembers everything you have told it, works with whatever model you choose, and answers to no one but you. Tlon runs a single-tenant server per user as a matter of course, the same infrastructure enterprises now stand up per-agent at great cost.

We bet on renting rather than building our own agent harness. We integrated OpenClaw and went from prototype to a waitlist beta in under a month: a small capability flag in the client, and a per-user agent sidecar with its own memory, personality, and scheduled jobs, launched publicly in February 2026.

The early cohorts were small, but they moved retention in a way no feature in five years had:

• Day-5 retention for the first agent cohorts reached 50%, the best we had ever measured
• Cohorts with an agent roughly doubled 7-day retention over cohorts without one

The numbers ended the argument. By March we had turned the company around that result: we repositioned the product as a messenger you own with personal AI inside, put unrelated initiatives on ice, and pointed the roadmap at agents.

The bet's costs arrived on schedule. Building on a fast-moving third-party harness meant upstream breaking changes could take down our internal fleet overnight, failures were often silent, and the model's quality read to users as our quality.

We answered with the discipline learned in 2025, building observability before features: a context lens showing every agent run's triggering message, output, and tool calls; production telemetry; and nightly model-graded evaluations. Renting got us to market in weeks and validated the thesis. It also showed us which parts of the stack we will eventually need to own.

The ship is still mid-turn. The clearest signal so far is that users who talk to both their agent and other people retain far better than users who do either alone: the agent gets someone in the door, and the people they meet keep them there. We are reshaping onboarding and the product's form around that insight, toward a shared workspace where people and their agents work together.

Five years in, the mission is unchanged: communication tools you meaningfully own. Agents are the first workload that makes newcomers care who owns them.