Building an Agentic Organization

What if the AI agents working alongside your team weren't guests bolted onto the side of your Slack channel, but actual members of it — with their own identity, their own memory, and a provable record of everything they've done?

That question sits behind almost every "AI agent platform" claiming to help a company run an org-wide agentic OS — one where agents can sit in client channels, draft work, and be held accountable for it, without whoever adopts them ending up maintaining a fragile pile of custom glue code as the price of admission.

The answer turns out to be simpler than "pick a platform." It's a story about one open-source project that already closes most of the gap, wherever your team happens to talk.

The bot-shaped hole in every chat app

Every major chat platform today treats AI agents as an afterthought bolted onto a human-first design: an integration, a webhook, a bot icon in the corner of the channel. That's workable, but it shows. Bots get rate-limited differently than people. Their identity lives and dies inside whichever platform's database happens to host it. And when something goes wrong, the only record of what an agent actually did is whatever your own server's logs say — which is only as trustworthy as whoever has admin access to that server.

OpenClaw: the brain, independent of which room it's in

OpenClaw is an open-source, self-hosted framework for defining an AI agent: its personality, its skills, its memory, and — critically — which tools it's allowed to touch. It's stewarded by an independent non-profit foundation, with no company owning it and no paid tier waiting in the wings. Roadmap decisions go through public RFCs.

The part that matters most here: OpenClaw treats the chat platform as an interchangeable detail. It already plugs natively into Slack, Discord, Telegram, Mattermost, and Buzz — bot identity, channels, private channels, DMs, threads, reactions, the works, on each. Define an agent once — its personality, skills, memory, tool permissions — and it can show up with a consistent identity across any or all of them at the same time, because the agent's definition and the channel it's reachable through are decoupled by design.

OpenClaw also treats "many named agents, routed by channel, able to hand off work to each other" as a first-class, documented concept. That matters more than it sounds — plenty of agent frameworks are built for one operator running one assistant. OpenClaw is built for a fleet.

That's the actual takeaway worth sitting with: an organization doesn't need to wait for anything to become agentic. Point OpenClaw at whatever your team already runs — Mattermost, Slack, whatever — define the agent properly, and it's a real, accountable team member this week, not on someone's roadmap.

One of those rooms works a little differently: Buzz

Buzz is a team chat and Git workspace open-sourced by Block (Jack Dorsey's company) in July 2026, built on the decentralized Nostr protocol. Functionally, from OpenClaw's side, it's just another channel — same connector pattern as Slack or Mattermost. What's different is under the hood: every agent gets its own cryptographic keypair as identity, and every message, reaction, and action is a cryptographically signed event.

It's worth being precise about what that actually buys you, because most of "agent as a team member" — its own identity and avatar, added to channels like a person, an audit log of what it did — is already native to Mattermost and Slack. If that were Buzz's whole pitch, it'd be fair to call it trivial. The one thing that's genuinely different: a Mattermost or Slack audit log is only as credible as the database behind it — an admin with the right access could edit it after the fact, in principle. In Buzz, every event is signed with the acting identity's own private key, verifiable independently of whoever operates the relay, even against a compromised admin account. That matters most when someone outside your organization needs to trust the record — a client, an auditor, a regulator — much less for a purely internal tool your own team already fully controls. Buzz also bundles Git into the same workspace as chat, which neither Mattermost nor Slack does natively.

None of that changes how you'd use it: OpenClaw ships an official Buzz connector, already used in production — real self-hosted Buzz workspaces have run multiple agents side by side, some powered by OpenClaw, one running directly on the Claude Agent SDK with no framework at all, coexisting as equal, cryptographically-identified members of the same rooms. It's an upgrade to the room, not a different way of defining the agent.

One gap either way, worth flagging: a true pre-action approval gate — actually blocking a risky action before it happens, not just logging it afterward — isn't finished on Buzz's own side yet ("infra exists, glue still drying," in their own words), and Mattermost/Slack don't have an equivalent either. That guardrail logic still has to be built on the OpenClaw side, whichever room you're using.

What about Hermes?

Hermes Agent, Nous Research's well-funded, well-built rival to OpenClaw, is worth weighing too. It's arguably the more polished codebase day to day, with concrete safety features already shipped rather than proposed — and its messaging gateway is genuinely nice engineering: Telegram, Discord, Slack, WhatsApp, Signal, and email all run through one unified process with a shared command interface, rather than each channel being its own bolt-on. If the only requirement is "one agent, reachable consistently across every channel a team uses," Hermes's gateway is arguably a cleaner piece of plumbing than OpenClaw's.

It can connect to Buzz too, though its own maintainers describe having tried three different integration paths to get there — a sign the pattern is still settling, not a mature, single connector the way OpenClaw's is. The bigger issue for an org-wide use case: that same unified gateway sits behind a single agent process, and Hermes describes itself, in its own docs, as "a single-tenant personal agent" — its own guidance for teams needing separation between agents is to run entirely separate installations, not define a fleet within one governed system. A clean multi-channel front door doesn't help much if there's only one brain allowed to answer the door.

Where that leaves you

• OpenClaw + whatever comms channel your team already runs — Slack, Mattermost, or Buzz if built-in cryptographic audit trails and a unified chat-and-code workspace are things you actually value — is the one to start with. Install the connector, define the agent, and it's live in a channel today.
• Hermes is worth a look if you want the sharpest single-operator or small-team agent tooling available and don't yet need the multi-agent, org-wide governance layer.

None of this requires betting on a single vendor's roadmap. Both are open source, both are moving fast, and the gaps that remain — pre-action approval gates, fine-grained permission scoping — are exactly the kind of thing a dev-led team can prototype or vibe-code a plugin for rather than wait on.

You don't need a new chat platform, a foundation roadmap to land, or a startup's next funding round to close before an agent can become a real, accountable member of your team. Point OpenClaw at the comms channel you already run, define the agent properly, and it's there today. Everything else — Buzz's audit trail, Hermes's gateway — is about how much further that foundation can go, not what's required to start.