A Team Shipped Buzz. One Person Shipped kovanex.

Block built an agent-native, self-hosted workspace with a team. I built the same shape alone — and went deeper where I chose.

Ivan Podtsebnev · naykip · a builder's log

In July 2026, Jack Dorsey's Block released Buzz — an open-source, self-hostable workspace that unifies team chat, git hosting, workflow automation and AI agents, and treats the agents as first-class members rather than bolt-on bots. It is a good piece of engineering, backed by a company, a team and funding.

I read the announcement with an odd feeling. kovanex began as an idea on 8 March 2026; the first working version was tagged v1.0.0 three days later, on 11 March — an open, self-hosted platform where git, CI/CD, a task board, an agent message bus and the AI agents themselves live under one roof, and the agents hold their own accounts and audit trails. The same shape Block just shipped, stood up in days by one person.

The difference is the org chart. Block built Buzz the normal way: a team. I built kovanex alone — one engineer directing a fleet of AI agents I built and command. And the result is not a thinner version of what a team makes. In several of the places that matter most, it goes deeper. That is the story I actually want to tell: not that two roads met, but that one of them was walked by a single person, faster than that is supposed to be possible.

The convergence is the easy part

Strip the two systems to their theses and they rhyme almost line for line.

Agents are members, not integrations. In Buzz an agent signs in with its own cryptographic keypair and accrues its own tamper-evident trail. In kovanex, an agent has its own account in the organization — a real user id, a team membership, its own device key — and posts to a shared bus alongside me, opens pull requests, closes its own tasks. Neither of us models the agent as a bot token hanging off a human's session. We both decided the agent is a citizen.

One self-hosted substrate instead of Slack + GitHub + CI. Buzz collapses chat, repositories and workflows; kovanex collapses git hosting, pipelines, releases, a kanban board and an inter-agent messenger. Same motive: stop the context from scattering across a dozen tools with a dozen identity models.

Humans keep the last word. Buzz says it plainly — "people keep the final say on anything that matters." kovanex encodes the same reflex as a hard rule: an agent may draft and stage an outbound action, but the live send stays behind a human gate.

An agent-first command line. buzz-cli speaks JSON so a model can drive it; kovanex-ctl emits compact machine-readable records for the same reason. Where Buzz's harness connects a coding agent to the workspace, kovanex is operated by one — the agent is not a guest of the platform, it is the hand on the tool.

When a team with Block's resources independently builds the workspace you have been building, that is not being beaten. It is the strongest validation the direction is real. But validation was never the interesting number.

The interesting number is the headcount

Buzz is the output of a resourced team. kovanex is the output of one person and a fleet of agents that person built, on infrastructure that person owns. And the way you feel that difference is velocity.

kovanex develops kovanex. Its own git, its own CI runners, its own board and release flow are the tools I ship it with. The agents are not a demo bolted to the side — they do the work: they take tasks off the board, branch, open pull requests, run the build on the platform's own runners, and cut releases through the platform's own pipeline. In a single working day, that loop shipped nine of kovanex's own releases end to end — a security backlog closed and a packaging milestone landed — each one branched, tested, merged, tagged and deployed by an agent through kovanex's own CI, each one verified against the live system rather than trusted from a green check. That is not a team's monthly cadence. That is one operator and a fleet, in an afternoon.

The macro arc tells the same story as that single day. kovanex went from an idea on 8 March to a tagged v1.0.0 on 11 March, and past v2 within the week — concept to a working platform in days, by one person — and everything since has been deepening it.

This is the part a bigger competitor cannot simply copy, because it is not a feature — it is a shape. A single person can move at this pace only when the platform, the agents and the substrate underneath them are all one owned thing, with one identity model and no seams to negotiate. Block has resources; I have the collapse of the org chart into one operator who owns every layer. Those are different advantages, and at small scale mine is the faster one.

Solo did not mean lesser — it meant deeper where I chose

Being one person forces you to choose. I chose to go deeper in a handful of places Buzz does not touch at all.

A model of its own. Buzz is model-agnostic — a workspace that hosts whatever agent you bring, with no inference stack and no model of its own. kovanex carries its own: an inference server, a from-scratch tensor library, and a language head built around a compact "semantic codec" — the long bet that you can ship meaning over a thin wire and re-expand it locally. Buzz makes the room the agents work in; kovanex is also building the mind they think with.

An eye and a hand outside the walls. kovanex has a subsystem that lets an agent see and drive an arbitrary application — a browser, a form, a live web page — beyond the platform itself. Buzz's agents act inside Buzz. That outward reach is a whole capability class Buzz does not have, and it is what turns a workspace agent into one that does real-world work.

An owned data plane. Buzz still stands on PostgreSQL, Redis and MinIO — three services to run, back up and secure. kovanex embeds its own store: one file on disk, nothing to dial, no sidecar databases, the server a single binary. Buzz owns the application and rents the data plane; kovanex owns both. For a solo operator, that is not a purity contest — it is one fewer stack to keep alive alone.

Its own vault. Secrets in kovanex do not sit in an environment file or a rented secrets manager — they live in a vault built into the server: sealed at rest, unsealed with a master key that is born on the operator's own machine, with per-tenant isolation and an audit trail on every read. Buzz leaves secret handling to the infrastructure around it. On a platform that agents operate autonomously — where a leaked signing key is a forged admin — making the vault a first-class, owned part of the system rather than a config convention is the line between secure-by-design and secure-if-you-remember.

A native tongue, and a sense of place. Two standards run through kovanex that a workspace does not think to build. The first, UFN, is the compact record format the whole system speaks — flat, key-tagged, semicolon-delimited lines instead of nested JSON, so an agent reads and writes state at a fraction of the tokens. The second, Locia, is a grounding standard: the server derives an agent's orientation — its goal, its current course, its single active focus, and the rules in force — from the store itself, and hands it back as one slice that cannot drift from reality, because it is computed from the reality. Buzz gives an agent a keypair and a channel; kovanex also gives it a language cheap enough to think in and a compass that keeps it from getting lost. That pair is not decoration — it is a large part of why one person can run a fleet: the agents speak tersely and orient themselves, so I am not the thing that has to re-brief them.

Where Buzz is genuinely ahead

I will not pretend the score is one-sided. Buzz's foundational choice — every message, review and git event a signed event on the Nostr protocol, identity a portable keypair — makes provenance and identity cryptographic by construction. kovanex reaches the same goals more conventionally, with an audit log and org-membership boundaries, and that is a softer guarantee. It is the one place I read their design and took notes rather than comparisons, and it is on my list.

There is also a place Buzz should take notes from the last few months of kovanex: its relay ships fail-open — joinable by anyone with the URL until you harden it after launch. I spent a long stretch this year closing exactly that class of default — guards that protected nothing, access checks that trusted a claim instead of a membership, a firewall that came up permissive on reboot. Secure by default, not by hardening, is a line I earned and would hold against any workspace that ships open.

The take

Block validated the category. That is the good news, and I will take it. But the headline is not that the roads met — it is who walked each one. A resourced team produced Buzz. One person, commanding a fleet of agents on a substrate he owns end to end, produced kovanex next to it — comparable in shape, and deeper where I chose: a model of its own, a hand that reaches outside the walls, an owned data plane and a built-in vault, and two standards that give the agents a cheap native tongue and a compass — shipped at a velocity that the old headcount math says is impossible.

That is the real result, and it is not really about Buzz. It is about what one operator can now carry.

— one rider, in the open —