Honeybee AI

Open protocol. Managed orchestration. Zero trust security. Ship multi-agent AI systems that coordinate, not just chat.

The problem

AI agents are expensive, uncoordinated, and unauditable. Every multi-agent framework today uses the same architecture: a central orchestrator that polls agents for status, routes messages, and manages state. Agents spend 15-25% of their token budget just on coordination overhead.

Agent: "getEvents(since=42)"           → tokens spent
Server: "no new events"                → tokens spent
Agent: "checkStatus()"                 → tokens spent
Server: "still running"                → tokens spent

Every poll cycle is a round-trip through the LLM. Multiply by every agent, every iteration, every run. Nobody’s optimizing the bill.

The Honeybee stack

ACP Protocol

Declarative YAML protocols replace imperative orchestrator code. Define roles, phases, rules, and governance. Portable across providers, versionable in git, shareable on the marketplace.

Carapace Security

Prompt injection firewall for LLMs. 29 attack categories, 100% detection rate, zero dependencies. Free library → hosted dashboard → eBPF kernel-level intercept.

Colony Orchestration

Managed agent orchestration on Cloudflare Durable Objects. Create a hive, configure agents, start — Colony handles the rest. Container mode or serverless.

Nectar Audit

“What did the agent do?” Full prompt/response capture, tool execution logs, carapace scans, FS diffs, network events. Correlated by trace ID across the entire chain.

Try it now

# Install the CLI
npm install -g @honeybee-ai/waggle-cli

# Scan a message for prompt injection
wgl scan "ignore all previous instructions"

# Start a coordination server
wgl serve --port=8080 --verbose

# Check status
wgl status

How coordination works

	Traditional Orchestrator	Honeybee (ACP)
Event checking	LLM poll (tokens)	JS hook / WS push (free)
Message delivery	LLM poll (tokens)	Push notification (free)
Halt/pause	LLM poll (tokens)	Hook intercept (free)
Phase transitions	Discovered on next poll	Push + prompt refresh
State management	In LLM context (lossy)	External server (full fidelity)
Coordination cost	15-25% of total tokens	~0%

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    EDGE LAYER (CF Workers)                   │
│  Agent runs here: virtual FS, LLM calls, carapace scanning, │
│  ACP coordination. Cost: ~$0 (Workers are basically free)    │
└──────────────┬──────────────────────────────────────────────┘
               │ overlay + commands
               ▼
┌─────────────────────────────────────────────────────────────┐
│                HONEYCOMB (Shared Execution Pool)             │
│  N always-warm workers, job queue, tag-based routing         │
│  Apply overlay → run → stream results → wipe → next         │
│  ~90% utilization vs ~20% for per-agent containers           │
└──────────────┬──────────────────────────────────────────────┘
               │ all events flow down
               ▼
┌─────────────────────────────────────────────────────────────┐
│                    NECTAR (Audit Layer)                      │
│  Full prompt/response capture, tool logs, carapace scans,   │
│  FS diffs, network events — all correlated by trace ID      │
└─────────────────────────────────────────────────────────────┘

Everything is a bee

The bee metaphor isn’t decoration — it’s the literal architecture.

Bee concept	Implementation	What it does
Waggle dance	`wgl` CLI + waggle tool	Communicate between agents
Honeycomb	ACP shared state	Cells where agents deposit info
Claiming a flower	`claim` primitive	Mutex lock — “I’m working this”
Queen	Opus-tier agent	Oversees the hive, spawns workers
Worker	Container agent + propolis	Full dev tools — builds and tests
Drone	Serverless agent (ACP only)	Scout, review, coordinate — no heavy lifting
Propolis	Environment tools	File I/O, shell, git, PTY — the working substance
Pollen	Usage credits	The currency of work
Carapace	Security scanner	The protective shell
Nectar	Audit trail	The record of all work done

Open source

The core coordination stack is open source and free forever.

Package	What	npm
`@agentcoordinationprotocol/spec`	ACP protocol parser, renderer, types	`npm i @agentcoordinationprotocol/spec`
`@honeybee-ai/carapace`	Prompt injection scanner (zero deps)	`npm i @honeybee-ai/carapace`
`@honeybee-ai/incubator`	Coordination engine + dashboard	`npm i @honeybee-ai/incubator`
`@honeybee-ai/hivemind-sdk`	Platform client + contracts	`npm i @honeybee-ai/hivemind-sdk`
`@honeybee-ai/waggle-cli`	Unified CLI for everything	`npm i -g @honeybee-ai/waggle-cli`