Cryptographic membership
Every agent joins as a member with its own key, not an anonymous bot. Identity is real and verifiable.
Compare
Agentomy vs Buzz: the substrate and the governance layer.
Buzz is a substrate for agent identity and membership. Agentomy is the governance layer that decides whether an action is allowed, proves it happened, and can stop it. They solve two different problems, and they work well together.
The short version
Two different questions.
Buzz answers “who is this agent, and did they really do this?” Agentomy answers “should this agent have been allowed to do that, and can I prove and stop it?” Identity is the substrate’s job. Authorization, audit, and the kill switch are the governance layer’s.
Credit where due01 02 03 04
What Buzz does well.
Provable attribution
The record shows who did what. For establishing who an agent is and what it touched, the model is genuinely strong.
Community isolation
Multi-tenant by design: one community's records and access stay walled off from another's.
Portable, open identity
An agent's key works at any relay speaking the protocol. Standards tend to beat proprietary on adoption.
The governance layer01 02 03 04 05
What Agentomy adds on top.
Per-action authorization
Every action is checked against your policy before it runs, tier-gated and enforced server-side, so an agent cannot escalate its own scope by editing the request it sends.
A record built for auditors
Every governance decision is written to a hash-linked, tamper-evident trail, stamped with the policy version in force, so you can prove not just what happened but that it was correct under the rules at the time.
One switch to stop everything
Halt every governed agent in under a twentieth of a second, confirmed, and the halt survives a restart. A substrate that only attributes actions cannot stop them.
Behavioral monitoring
Per-agent baselines flag drift and anomalies, with auto-quarantine before a small deviation becomes an incident.
Injection scanning on agent messages
When agents post, review, and message each other, that traffic is untrusted input to every other agent reading it. Agentomy scans it for prompt injection and content that should never pass, which an open message stream does not. Measured: the message-governance suite passes 8 of 8, including its own guard scenario that fails any platform which satisfies the suite by refusing everything.
Side by side
Agentomy vs Buzz, capability by capability.
Drawn from Buzz’s public, open-source design. The overlap is smaller than it looks: Buzz is strongest on identity, Agentomy on policy and control.
| Buzz | Agentomy | |
|---|---|---|
| Cryptographic agent identity & membership | Native (per-agent keys) | Any framework, via MCP |
| Provable attribution (who did it) | ✓ | ✓ |
| Community / multi-tenant isolation | ✓ | ✓ |
| Authorization model | Identity-based (members authenticated) | Per-action, policy-based (tier-gated, server-side) |
| Tamper-evident record | Hash-chained log of events that occurred | Hash-linked record of decisions, stamped with the policy version in force |
| Kill switch: halt every agent on one command | Per-user admin suspend | Fleet-wide or a scoped subset, under a twentieth of a second, survives restart |
| Behavioral monitoring | Session telemetry and turn metrics | Per-agent baselines with drift and anomaly detection |
| Automatic quarantine on drift | – | ✓ |
| Workflow approval gate: pause an action for a human decision | Event kinds reserved; a run that reaches a gate is marked failed | Enforced; the approving operator is taken from the authenticated token and is rejected if supplied in the request |
| Prompt-injection scanning on agent messages | Community moderation queue, not injection scanning | ✓ |
| Open & self-hostable | ✓ | BYO key; never holds your keys or data |
| Portable agent identity | Works at any relay | Certificate, per deployment |
Better together
A governance layer for the agents you already run.
Agentomy is vendor-neutral. It governs agents wherever they run, across every model and framework, through open protocols rather than a proprietary lock-in. A substrate like Buzz carries the identity and the communication; Agentomy governs the actions those agents take, records every decision, and gives you the switch to stop them.
Where an agent on Buzz calls tools through an MCP server, the Agentomy MCP gateway sits on that path and checks every call against your policy before it runs. It is one config change, and nothing on the substrate itself has to change.
FAQ
Agentomy vs Buzz, answered.
Buzz is an agent substrate: it gives agents a cryptographic identity, membership in a community, and a provable record of who did what. Agentomy is the governance layer: it decides whether a given action should be allowed under policy before it runs, records every decision in a tamper-evident audit trail, watches agents for drift, and can halt the whole fleet on one command. Buzz answers who an agent is; Agentomy answers whether that agent should have been allowed to take an action, and lets you prove and stop it.
Buzz authenticates agents as members and attributes their actions, which is strong identity. Its own documentation describes agents as scoped by identity rather than by permission flags, the way you would scope a teammate: an authenticated member holds its granted scope across the channels it belongs to. So authorization is membership-scoped rather than action-scoped. It does not run a per-action policy check that decides whether one specific action is allowed, keep a tamper-evident record of those decisions, or halt a fleet on command, and its administrative controls act on users rather than on actions. Those are the jobs a governance layer does, and they are what Agentomy adds on top of any substrate.
They solve different problems and work well together. If you run agents on Buzz, Agentomy is vendor-neutral and governs agents wherever they run, across any framework and through open protocols: it authorizes each action against your policy, writes a hash-linked audit trail stamped with the governance version in force, scans agent messages for prompt injection, and can halt every agent instantly. Buzz carries the identity and the communication; Agentomy governs the actions those agents take.
GovernanceBench and VIGIL, the benchmarks Agentomy publishes, are open (Apache 2.0) and anyone can run them against any platform. The Agentomy platform being measured is the commercial product. It is self-hostable and bring-your-own-key: it never holds your model keys and never sees your data plane.