DEEPDIVE / [LAB] · CLAUDE DESKTOP BUDDY № 02 ← № 01 Value
v1 · 2026
PROTOCOL ARCHAEOLOGY

Buddy
Protocol Deep Dive

From the BLE bitstream to
the future of agent hardware communication protocols

A layer-by-layer teardown of the claude-desktop-buddy protocol, plus a prediction of how agent-hardware communication protocols will evolve. Deconstruct reality first, then project the future.

PARTS
4
Bitstream → Future
Protocol Layers
17
sections / decision tables
Anthropic Protocols
6
MCP → Buddy
Future Proposals
3
should exist
Sister Article

The product-angle companion piece: Value — What Buddy Means for Developers. This deep dive is the full technical teardown, from the BLE physical layer to the protocol future, all in one go.

TL;DR / 30 seconds

Buddy is Anthropic's sixth public protocol—and the only physical proximity protocol among them, the first to draw a line around the interface between agent ↔ physical hardware.

Counter-consensus insight: The protocol looks like a maker toy on the surface, but at its core it's Anthropic betting on "agent physical presence" as a product dimension—it's worth reading not for what it can do now, but because it stakes out a position no previous protocol occupied.

PROLOGUE

What this article sets out to do

The Buddy protocol looks like a maker toy's interface specification on the surface. Dig deeper and you'll find three things worth discussing:

  1. 01 It is Anthropic's sixth public protocol—the previous five being MCP, Skills, Hooks, Permissions, and Remote Control. Each corresponds to a layer of the agent workflow.
  2. 02 It is the only physical proximity protocol among them. The other five are all software interfaces or network protocols; Buddy is the first time this company has defined the contract between an agent and "physical hardware."
  3. 03 Its design choices reflect an as-yet-unpublicized judgment: an agent's "physical presence" is a product dimension, worth supporting with a standalone protocol.

This article is divided into four parts:

PART I

Bitstream Layer

Layer-by-layer teardown from the BLE physical layer to JSON application semantics

PART II

Design Analysis

6 key decisions, 4 smart moves, 5 gaps, threat model

PART III

Protocol Stack Positioning

Horizontal comparison of Anthropic's 6 protocols, which cell Buddy occupies

PART IV

Future

5 evolution directions + 3 protocol proposals that should exist

Written for: protocol designers, engineers building agent toolchains, makers who want to connect hardware to AI, product people interested in protocol-as-product.

§ 01 / WHAT

What is this

claude-desktop-buddy is an open-source reference implementation from Anthropic, consisting of two things:

You don't need any code from this repo to interface with the API—just a dev board that can advertise the Nordic UART Service and this protocol document. The repo exists to give the maker community a ready-to-fork, ready-to-flash starting point.

REPO ARCHAEOLOGY

1.6k Stars, 218 Forks, but only one Contributor: Felix Rieseberg (Electron core maintainer, former lead author of the Slack desktop client). The entire repo has only 2 commits. This isn't an organically grown open-source project—it's a clean-scrubbed version of some internal project open-sourced after cleanup. We'll come back to this detail in § 17 when discussing strategy.

M5StickC Plus running buddy firmware
FIG / 01 M5StickC Plus running buddy firmware — the protocol's reference target
§ 02 / DOES

What it can do

Once connected, the hardware gets real-time Claude status—session count, running/waiting counts, cumulative tokens, current permission requests. Status maps to 7 animations on the device (see Value № 01 status table).

The key interaction is the approval flow: when Claude executes a tool call requiring user confirmation—Bash commands, file operations, etc.—the device screen shows approve: Bash with a specific command preview. Press A to approve, press B to deny. The entire process doesn't require looking at the computer screen.

This solves a real pain point: when Claude Code runs long tasks, it occasionally stops to wait for approval, and you need to switch back to the computer window to click. With this device, you can continue doing other things and just glance over and press a button when the pet gets impatient.

The product significance of this small thing was covered in № 01 Value. This article cares about: what protocol implements this small thing, and why it's implemented this way.

PART I — PROTOCOL SHAPE
Bitstream Layer
§ 03 / STACK

Protocol stack structure

The Buddy protocol has four layers. Each layer has a story. Let's look from the bottom up.
Application Semantics JSON messages (heartbeat / permission / turn / status / char_*)
▲ ▼
Framing UTF-8, \n-delimited lines (line-buffered)
▲ ▼
Transport Nordic UART Service (NUS) over BLE GATT
▲ ▼
Physical Bluetooth Low Energy 4.2+ / 5.0
§ 04 / TRANSPORT

Physical + Transport Layer

4.1 / Why BLE instead of WiFi / USB / UWB

Candidate comparison:

Candidate
Range
Pairing
Power
Debug
Cost
BLE
~10m
Once
Ultra-low
High
$
WiFi
~30m
Router
Medium
Medium
$
USB
Contact
Plug-in
Bus
High
$
UWB
~10m
Complex
Medium
Low
$$
5G
Global
SIM
High
Low
$$$

Buddy's choice of BLE can be reverse-engineered:

USB is also a reasonable candidate, but requires the device to be wired to the host; BLE lets the device be placed freely—this freedom matters for an ambient device.

4.2 / Nordic UART Service — Why not invent a new GATT

NUS is a de facto standard, with three GATT characteristics:

Service:  6e400001-b5a3-f393-e0a9-e50e24dcca9e
RX (W):   6e400002-b5a3-f393-e0a9-e50e24dcca9e   // Host → Device Write
TX (N):   6e400003-b5a3-f393-e0a9-e50e24dcca9e   // Device → Host Notify

Why use NUS instead of designing a Buddy-specific GATT profile?

Consistent with MCP's JSON-RPC 2.0 over stdio/SSE—both reuse existing standards as the transport base, putting all the novelty into the application semantics layer.

4.3 / Advertising name prefix: Claude*

The device advertising name must start with Claude. This is a simple convention that replaces several more complex alternatives:

Side effect: anyone can advertise Claude_xxx to impersonate a device. But within BLE range, this needs to be protected by the encryption layer anyway (§ 11); it's not something a naming convention should solve. Use the right tool for the job.

4.4 / MTU limitations — Protocol layer is MTU-agnostic

BLE 4.0 ATT_MTU defaults to 23 bytes; after header overhead, a Notify can only send 20 bytes. BLE 5.0 can negotiate up to 247 bytes. But you can't assume the client has negotiated a large MTU.

Buddy's approach is clever: the protocol layer is MTU-agnostic.

// Sender
Serialize JSON to UTF-8 → write bytes to NUS RX/TX → natural packet fragmentation

// Receiver
Buffer all received bytes → parse a line when \n is encountered

This means:

Resistant to MTU drift + resistant to transport replacement. Any lower-layer change requires zero protocol modifications. This is valuable design redundancy.

§ 05 / FRAMING

Framing Layer — Why \n-delimited JSON

Candidate approaches:

Framing Method
Pros
Cons
\n-delimited lines
Easy to debug, zero overhead, even telnet works
Payload cannot contain \n
Length prefix
Strict, binary-safe
Requires parser, needs tools to debug
LTV
Clean multi-type dispatch
High complexity
WebSocket frame
Mature
Header overhead

Buddy chooses \n. This requires that JSON serialization produces no raw newlines—all JSON is single-line (minified).

Benefits
  • · Unbeatable debugging—read JSON directly from bluetoothctl
  • · Simple stream processing—readline() in any language
  • · Error recovery—one line failing to parse doesn't affect the next
Costs
  • · Binary must be base64 (+33% per chunk)
  • · No native message boundary guarantee

This is a choice of debuggability over bandwidth. Buddy's throughput needs are very low (heartbeat once every 10s, status pushes every few seconds); the debuggability benefit far outweighs the bandwidth cost.

§ 06 / MESSAGES

Application Semantics Layer — Five Message Types

The Buddy protocol has only 5 message families at the application layer. Let's break them down one by one.

6.1 / Heartbeat Snapshot (Device ← Desktop)

{
  "total": 3,
  "running": 1,
  "waiting": 1,
  "msg": "approve: Bash",
  "entries": ["10:42 git push", "10:41 yarn test", "10:39 reading file..."],
  "tokens": 184502,
  "tokens_today": 31200,
  "prompt": {
    "id": "req_abc123",
    "tool": "Bash",
    "hint": "rm -rf /tmp/foo"
  }
}

Key Contracts

Frequency Contract

Sent on state change, at most once every 10 seconds for keep-alive. 30 seconds without data means connection is dead. The device must implement a "30s no data" timeout logic, and must not rely on BLE link state.

Idempotency Contract

Each heartbeat is a complete snapshot, not a delta. The device can discard old heartbeats and only look at the latest one. This greatly simplifies the state machine—no reconciliation needed, just overwrite.

Pre-aggregation Contract

entries are already strings, not structured logs; tokens are already accumulated; prompt.hint is already truncated. All aggregation is done on the desktop side; the device only displays. Complexity is pushed to the host side; the device acts as a "dumb terminal."

6.2 / Permission Approval (Device → Desktop)

{"cmd":"permission","id":"req_abc123","decision":"once"}
{"cmd":"permission","id":"req_abc123","decision":"deny"}

Contracts:

The last point is key. The Claude Code desktop client itself has an "always allow" mode; Buddy intentionally prevents the device from triggering it.

Design Intent

Physical friction is a feature, not a bug. If you could "tap once on Buddy to permanently allow git push," the device would degrade from "approver" to "numb rubber-stamper." Buddy's product value lies in the light friction of "glance + press" for each approval—this friction itself prevents a class of errors. Once you allow "always," the entire product value collapses.

This kind of restraint—"the protocol deliberately withholds a capability"—is rare. Most protocol designers think "provide it to the client, let the client choose whether to use it"—Buddy does the opposite: it forbids the client from having this choice. This is an example of a product decision hardened into the protocol.

6.3 / Turn Event (Device ← Desktop, asynchronous)

{
  "evt": "turn",
  "role": "assistant",
  "content": [{"type": "text", "text": "..."}]
}

Triggered once after each Claude reply completes. The content array is in the SDK's native format (text / tool_use / tool_result). Events exceeding 4 KB are dropped.

Why 4 KB? Engineering constraint-driven:

Design intent: Turn is not for the device to fully replicate the conversation, but to trigger a "Claude spoke" animation. If you want complete logs, use a different transport (USB direct, WiFi). Buddy's role on BLE is "status indicator," not "log synchronizer."

6.4 / Status Report ACK (Desktop ← Device)

{
  "ack": "status",
  "ok": true,
  "data": {
    "name": "Clawd",
    "sec": true,
    "bat": {"pct": 87, "mV": 4012, "mA": -120, "usb": true},
    "sys": {"up": 8412, "heap": 84200},
    "stats": {"appr": 42, "deny": 3, "vel": 8, "nap": 12, "lvl": 5}
  }
}

Desktop polls, device responds. The weakest contract in the protocol—every field is optional; if the device doesn't support it, it simply doesn't fill it in.

stats.lvl is the "level" tracked by the device itself (leveling up every 50k tokens), reported back to the desktop. This state is not maintained by the desktopthe device's NVS is the single source of truth. Another restrained design: let the device own the state it displays; the desktop is just a consumer.

6.5 / Folder Push — Streaming Character Pack Transfer

The most complex part of the protocol. Triggered when the Hardware Buddy window's drop target receives a folder:

Desktop: {"cmd":"char_begin","name":"bufo","total":184320}
Device: {"ack":"char_begin","ok":true}
— per file —
Desktop: {"cmd":"file","path":"manifest.json","size":412}
Device: {"ack":"file","ok":true}
Desktop: {"cmd":"chunk","d":"<base64>"}
Device: {"ack":"chunk","ok":true,"n":4096}
… repeat chunks until size bytes are transferred …
Desktop: {"cmd":"file_end"}
Device: {"ack":"file_end","ok":true,"n":412}
— pack end —
Desktop: {"cmd":"char_end"}
Device: {"ack":"char_end","ok":true}

Design Highlights

CHUNK-level ACK = Flow Control

Desktop doesn't send the next chunk until it receives the previous ack—application-layer stop-and-wait. The BLE link layer has ACKs, but this application layer lets the protocol sense "the device flash write is slow"—the device just delays the ack, and the desktop naturally slows down.

n field = Progress

Returns cumulative byte count, providing the desktop with progress bar data—no separate calculation needed.

PATH validation = Receiver's responsibility

The protocol specification requires the receiver to reject .. and absolute paths. Defense-in-depth as protocol compliance—when the desktop is compromised and sends a malicious path to the device, the device itself must still reject it.

Content-agnostic = Protocol Reuse

GIFs, configs, firmware images all work. This means the protocol can extend to support new content types in the future without modifying the wire format—OTA, wallpaper, sound packs. Protocol = abstraction, not a specific feature.

6.6 / Character Pack Manifest Format

Within the content transferred by Folder Push, the schema of manifest.json:

{
  "name": "bufo",
  "colors": {
    "body": "#6B8E23",
    "bg": "#000000",
    "text": "#FFFFFF",
    "textDim": "#808080",
    "ink": "#000000"
  },
  "states": {
    "sleep": "sleep.gif",
    "idle": ["idle_0.gif", "idle_1.gif", "idle_2.gif"],
    "busy": "busy.gif",
    "attention": "attention.gif",
    "celebrate": "celebrate.gif",
    "dizzy": "dizzy.gif",
    "heart": "heart.gif"
  }
}

This manifest is the only place in the Buddy protocol with a strong constraint on specific content format. All other wire formats are structure (message families); the manifest is data (assets). The benefit of isolating the content format into a small schema: the protocol stays unchanged while assets can evolve independently—v2 adds a sound field linking to audio files; old devices read and ignore it, new devices enable it.

§ 07 / HARDWARE

Hardware Reference Implementation

The protocol specification is abstract. Anthropic provides a concrete hardware reference implementation: the M5StickC Plus.

7.1 / M5StickC Plus Button Mapping

Button
Normal
Pet Page
Approval Page
A Front
Switch screen
Switch screen
Approve ✓
B Side
Scroll conversation
Next page
Deny ✗
Long press A
Enter menu
Enter menu
Enter menu
Power short press
Screen off
Power long press 6s
Hard power off
Shake
Trigger dizzy
Face down
Sleep & heal

Screen auto-off after 30 seconds of inactivity, stays on when an approval is pending.

Note how "button meaning changes with state"—the same button means completely different things on different pages. This is a manifestation of the protocol design letting the device decide button semantics: the protocol only specifies "device sends once/deny," not "which button sends which." Device developers have complete freedom.

7.2 / Flashing Method

# Install PlatformIO Core, then:
pio run -t upload

# Starting from a fresh device, erase first:
pio run -t erase && pio run -t upload

The repo's platformio.ini already configures the board, partitions, and file system. The uploadfs target writes the filesystem separately (for character pack hot updates).

7.3 / Adapting to Other Hardware

The firmware core ble_bridge.cpp only depends on the Nordic UART Service, hardware-independent. M5StickCPlus-specific code is concentrated in buddy.cpp and the display driver layer.

Need to change
  • · Display driver
  • · Button GPIO mapping
  • · IMU interface (optional)
No need to touch
  • · BLE layer
  • · JSON protocol parsing
  • · State machine
Alternative hardware
  • · nRF52 series
  • · ESP32-S3
  • · Raspberry Pi + BLE
  • · PC + USB BLE dongle

Any device that can advertise the Nordic UART Service can connect. Hardware independence of the protocol is the core design promise—which is why the NUS choice was so important (§ 4.2).

PART II
Design Analysis
§ 08 / DECISIONS

Six Key Decisions

#
Decision
Alternative
Why this one
Cost
1
NUS over BLE
Custom GATT
Ecosystem, debug, posture
None
2
JSON
CBOR / MsgPack
Debug, readable, any language
Bandwidth + base64
3
Line-delimited
Length prefix / LTV
Text-readable, zero parser
Payload cannot contain \n
4
Single-shot decision
once/always/whitelist
Protect approval's physical friction
Device can't cache rules
5
No version field
v: "1.0"
Simple now
Painful schema evolution later
6
4 KB Turn limit
Large frame fragmentation
Prevent abuse, preserve BLE bandwidth
Long replies can't be fully transmitted
SYNTHESIS

Each decision is reasonable on its own. Read them together and you'll notice a pattern: Buddy consistently leans toward "simple now" over "flexible later". This is a reasonable choice for an early product—but it means v2 will inevitably require a breaking upgrade. The designers are clearly aware of this (2 commits in the repo, documentation explicitly stating "no version negotiation yet").

§ 09 / DESIGN

Four Noteworthy Designs

9.1

Protocol layer is MTU-agnostic

Through \n delimiting + byte stream writes, BLE MTU, fragmentation, and reassembly are pushed to the endpoint buffers. Makes the protocol require zero modifications when the transport layer upgrades.

9.2

Path validation responsibility on the receiver

Not simply "both sides validate"—but explicitly writing the validation responsibility into the protocol specification. Any device connecting to Buddy must implement it, otherwise "protocol compliance" doesn't hold.

9.3

Chunk-by-chunk ACK as natural flow control

Application-layer ack/n is simultaneously confirmation, progress data source, and flow control signal. One field, three purposes. Much cleaner than splitting into ack + progress + flow_control.

9.4

Host pre-aggregation + device dumb display

Entries are strings, tokens are accumulated values—what the device receives is the "final display form," with zero computational overhead. Device firmware can be very small; the evolution path is primarily on the host side.

§ 10 / GAPS

Five Obvious Gaps

To be fair, let's list the gaps clearly too.

  1. 10.1

    No version negotiation

    The protocol has no version field. Adding new fields to the schema is tolerable (JSON tolerates unknown keys), but semantic changes (e.g., renaming decision: "once") will break things silently with no warning.

    Fix path: add proto: "1.0.0" to the status ack, desktop degrades accordingly.

  2. 10.2

    Single-decision permission model lacks a rule engine interface

    The protocol's prohibition of "always" is a sound design (§ 6.2), but it means you can't implement a rule engine at the protocol layer—e.g., "auto-approve read operations / require manual approval for write operations." To do this, you'd have to add a middleware proxy outside the desktop.

    This is intentional—Buddy emphasizes "human in the loop." But the rule engine use case should be covered by another protocol; Buddy shouldn't do it.

  3. 10.3

    No tool call progress events

    The device only sees "N running," not which specific step has been reached. A Bash command running for 3 minutes—the device can't display "1m20s elapsed."

    Fix path: add evt: "tool_progress" event stream, pushed every 5s.

  4. 10.4

    Cannot distinguish multiple sessions

    The device sees aggregated total / running / waiting. If you have 5 Claude Code sessions open simultaneously with 3 needing approval, you can't pinpoint the specific session. Fine for single-device single-user; useless for team scenarios.

    Fix path: add sessions: [...] array to the heartbeat.

  5. 10.5

    Unidirectional (device cannot push content back)

    The device can only: ① return approval decisions, ② report status. It cannot push prompts, cannot comment on Claude replies, cannot trigger mode switches. Based on the Buddy protocol, you can't build "press B to have Claude summarize the current session."

    This is determined by the current positioning—it's an "indicator + switch," not an "input device." Anthropic's restraint in not releasing this now is reasonable; § 15 will expand on this.

§ 11 / SECURITY

Threat Model +
LE Secure Connections Trade-offs

Attack Surface

The Buddy protocol transmits:

An unencrypted BLE link can be recorded in real-time by a cheap nRF sniffer (< $30) within ~10m range. The documentation explicitly recommends implementing LE Secure Connections bonding, but does not mandate it.

Why not mandate encryption?

  1. 1. Maker-friendly: Many dev boards used by makers don't have BLE encryption enabled by default. Mandating it would significantly raise the barrier to entry
  2. 2. Pairing UX pain: BLE bonding requires the user to enter a 6-digit passkey or yes/no—troublesome for devices without screens
  3. 3. Threat model realism: Someone who can physically approach your desk can probably already see your screen—encrypting BLE doesn't prevent over-the-shoulder attacks

My judgment: OK for personal dev desktops, completely not OK for enterprise environments. If Anthropic wants to push Buddy into SOC2/HIPAA-compliant environments, bonding must be mandatory. This requires adding a sec: required field at the protocol layer.

Defense Layers

Implementing a production-grade Buddy device should:

Must
  • 1. Implement path traversal validation
  • 2. prompt.id strict matching (reject echoing old IDs)
Recommended
  • 3. LE Secure Connections + DisplayOnly + 6-digit passkey
  • 4. NUS Char + TX CCCD marked encrypt-only
  • 5. Advertising only enabled for 60 seconds after user presses button
Optional — but interesting

6. Add a deny blacklist on the device—certain tool names (e.g., Bash containing rm -rf /) are rejected even if the user presses A. Give the device veto power, not just approval power. This goes beyond the protocol's explicit provisions, but is compliant—the protocol allows the device to deny; it doesn't mandate that the deny basis must be a user button press.

PART III
Protocol Stack Positioning
§ 12 / ECOSYSTEM

Anthropic's Six Protocols

By 2026, Anthropic has six public, developer-facing protocol specifications. Together they form the open interface surface around the Claude agent.

Protocol
Scope
Transport
Serialization
Primary Actor
Shipped
MCP
agent ↔ external data/tools
stdio · SSE · HTTP
JSON-RPC 2.0
Third-party tool makers
'24-11
Skills
agent ↔ user scripts
Filesystem conventions
MD + YAML frontmatter
Users / plugin authors
'25
Hooks
agent ↔ user hooks
stdin / HTTP / MCP
JSON
Users
'25
Permissions
agent ↔ security policies
Config files
JSON DSL
Users / admins
'24-25
Remote Ctrl
agent ↔ remote humans
HTTPS over cloud
(Not public)
Anthropic
'26-02
Buddy BLE
agent ↔ physical proximity
NUS / BLE
JSON · line
Any maker
'26

Each protocol covers a different facet of the agent workflow:

                ┌─ Tool discovery/invocation  MCP
                ├─ User orchestration/playbook Skills
agent workflow  ←──┼─ Events/hooks              Hooks
                ├─ Boundaries/policies        Permissions
                ├─ Remote control             Remote Control
                └─ Physical proximity indicator Buddy BLE  ← Buddy's cell
§ 13 / NICHE

The Only Layer Buddy Covers
Physical Proximity

The first five protocols are all software interfaces or network protocols—you interact with the agent via code, configuration, or HTTPS. Buddy is the first specification to explicitly designate a "physical proximity device" as a protocol collaborator.

Why is this layer worth a standalone protocol? Software interfaces (MCP, Hooks) can inject tools or hooks into the agent at runtime, but they can't solve the "how do you know the agent is running in the background" problem—you have to switch windows to check. Physical proximity devices fill this gap perfectly: making agent state perceivable without stealing focus.

Always in peripheral vision

No need to open a window

Dynamically attracts peripheral attention

Human eyes are far more sensitive to motion than to static elements

Physical interaction friction

Pressing a hardware button ≠ clicking OK

Buddy is designed for these three things. It can't replace a screen, but it supplements it—specifically serving the scenario where "agent status needs to be perceivable in peripheral vision."

This is a new surface area. Anthropic stakes a claim on it with a small protocol, letting the maker community fill in the content first. Three years from now, when this surface is validated as having product value, they'll decide whether to release their own official hardware.

§ 14 / DIFF

Horizontal Comparison Depth

vs MCP — Both JSON, but target audiences are opposites

Dimension
MCP
Buddy
Invocation pattern
RPC (request-response)
Event stream + point responses
Who initiates
Agent actively calls tools
Desktop actively pushes state
Implementer
Tool developers
Hardware makers
Entry barrier
Write an npm/pip package
Flash firmware
Programming paradigm
Server-side
Embedded

Although both use JSON, both are designed by Anthropic, and both transports could be stdio/socket—the people and scenarios they target are worlds apart. Merging them would be a mistake—protocol design should fit the reader, not pursue uniformity.

vs Remote Control — Same problem, opposite solutions

Remote Control (launched 2026-02) and Buddy both solve "how to operate the agent when not at the host." But the solutions are opposite:

Dimension
Remote Control
Buddy
Network topology
Client → Cloud ← Host
Device ↔ Host (direct)
Transport
HTTPS over TLS
BLE NUS
Range
Global
~10m
Authentication
claude.ai account
BLE pairing
Data flow
Via cloud
Fully local
Use case
Travel, cross-machine
Desktop, ambient, low-latency

These two protocols complement each other; they don't compete. Remote Control solves "I'm not at my computer but need to continue agent work," while Buddy solves "I'm at my computer but don't want to be interrupted by pop-ups."

Anthropic having both protocols—one cloud-relayed, one local direct—means different problems are solved with different physical topologies. Complementary, not competitive.

vs Computer Use — Opposite directions of visibility

Computer Use lets the agent see the screen, operate the mouse—the agent sees the desktop. Buddy lets the desktop see the agent's internal state—the desktop sees the agent.

Computer Use:    agent ──observe / operate──→ desktop   // agent is the active party
Buddy:           desktop ──state / decision──→ agent     // human / physical device is the active party

Both are interfaces between the agent and the physical world, but in opposite directions. Combined—agent watches screen to debug code, human approves git push on an ambient device—this is the complete form of the 2026 agent workflow.

vs Hooks — Protocol shape comparison

Hooks are in-process event hooks—PreToolUse / PostToolUse / PermissionRequest fire synchronously in the agent execution flow. Buddy is conceptually similar to a "hardware implementation" of the PermissionRequest hook.

Dimension
Hooks
Buddy
Deployment
User config files
Physical device
Latency
< 100 ms
100 ms – 2 s
Trust
Same-host process
BLE link (needs encryption)
Written in
Shell / Python / HTTP
C++ firmware

Anthropic was right not to merge Buddy into Hooks—Hooks are for developers writing code, Buddy is for makers connecting hardware. Two audiences require different protocol shapes.

PART IV
Future
§ 15 / EVOLUTION

Five Evolution Directions

Over the next 5 years, which directions will agent ↔ hardware communication protocols evolve toward?

  1. 15.1

    Bidirectional Intent

    Currently Buddy is a one-way bias of "host pushes + device returns approvals." The next step is letting the device actively push to the agent:

    • · A voice button on the desk, press and speak → convert to prompt → push to current Claude session
    • · A temperature/humidity sensor, pushing environmental data to the agent as context every hour
    • · An NFC tag stuck on a folder, tap it to have the agent read that folder

    Requires adding a cmd: "user_input" channel to the protocol. The security model becomes more complex—needs push rate limits, content length limits, host-side user-confirm popups.

  2. 15.2

    Local-first / No intermediary

    Buddy is already local direct. Remote Control is cloud-relayed. The future will bring a third mode: multiple local devices forming a network, with none of them needing cloud access.

    Concrete form: one Mac + one iPad + one desktop ambient + one wrist vibrator, all BLE-interconnected, agent state synchronized across four surfaces, any decision visible to the other three.

    Technical foundation: Matter / Thread / BLE Mesh / UWB. These standards are mature; what's missing is the semantic layer standardization for "agent state"—the Buddy protocol is the prototype of this schema.

  3. 15.3

    Multi-device fan-out

    One agent state pushed to multiple ambient peripherals. 1:1 → 1:N:

    • · One Mac → buddy + LED strip + e-ink dashboard + wrist vibrator
    • · Different surfaces display different abstraction levels

    Requires adding a subscription/filter mechanism to the protocol—device tells the host "I only care about attention events," and the host only pushes those events to it.

  4. 15.4

    Capability Negotiation

    A handshake phase must be added in the future:

    device → host: {"hello":{"proto":"1.2","caps":["nus","char_push","voice_in"]}}
    host → device: {"hello_ack":{"proto":"1.2","negotiated":["nus","char_push"]}}

    HTTP/SMTP/TLS all solved this before. Buddy is simple now because there's only one reference implementation; once the maker community builds 100 different devices, capability negotiation becomes essential.

  5. 15.5

    Tiered Trust Transport

    Different decision weights should travel through different physical channels:

    Decision Type
    Recommended Transport
    Root of Trust
    View state (read-only)
    BLE / WiFi / Cloud
    Any
    Approve read-only tools
    BLE paired device
    One-time pairing
    Approve file writes
    BLE + device PIN
    Pairing + local auth
    Approve prod deployments
    USB + physical key + second person
    Contact + multi-party
    Approve transfers / data deletion
    NFC + biometric
    Physical token + biometric

    Different operations have different blast radii; authentication strength should be proportional. Currently Buddy treats all permissions as one category—a reasonable simplification for early stage, but one that will inevitably need to be split in the future.

§ 16 / PROPOSALS

Three Protocols That Should Exist

This section is personal opinion. Based on the analysis above, I think there are three agent-hardware protocols worth existing that nobody has built yet.

PROPOSAL / 01 VOICE / GESTURE ~$30

Agent Wake

Give the agent a physical wake entry point

Problem: Currently invoking Claude requires opening the computer, opening a window, and typing characters. If you just want to say "check today's weather for me," the entire flow is too heavy.

Protocol: BLE device advertises Wake_*, after the host connects it receives a PCM audio stream ({cmd:"audio", d:"<base64>"}). Device has a button, microphone, possibly a small screen. Press and hold to speak, release to push the entire audio clip to the agent.

vs Echo: Echo is cloud-routed—you say "Alexa..." and it's all on AWS. The Wake protocol requires local audio processing, transmitting only within BLE range.

Implementation cost: ~$30 (ESP32 + I2S mic + button + 3D-printed case).

PROPOSAL / 02 QUORUM FINSEC

Distributed Approval

Multi-device voting

Problem: For high-risk operations (deleting a database, prod deployment, large transfers), having one person approve on one device isn't enough. But requiring "two people in a room for dual confirmation" is too heavy.

Protocol: When a high-risk operation is issued, the host broadcasts the approval request to a set of bound devices. M-of-N devices must approve (e.g., 2 of 3) before execution. Each device independently runs the Buddy protocol; the host performs vote aggregation.

Protocol delta: Add quorum: {n: 3, m: 2} to the prompt field; when the host receives decision: "once" from any device, it counts; execution triggers when count reaches m.

Use cases: Financial institutions, healthcare systems, production deployments. The agent form factor of Yubikey.

PROPOSAL / 03 PEER-TO-PEER A2A

Agent-to-Agent BLE

Proximity agent collaboration

Problem: Your Mac runs Claude Code, your colleague's Mac also runs it—there's no collaboration channel between the two agents (except having humans paste in Slack).

Protocol: Two Macs running Claude advertise ClaudePeer_* to each other, and after pairing establish a reverse NUS bridge. Each agent can query the other's session list, push prompts to the other's session, and subscribe to the other's turn events. Forming a desktop-level agent LAN.

Why BLE instead of WiFi/IP: Physical radius = trust radius. Devices within BLE range are people in the same room, which is inherently coarse-grained access control. WiFi/IP could let any attacker on the same LAN scan your agent.

Use cases: Pair programming (both Claudes share context), code review (have the other agent check your PR), multi-user home sharing an agent.

§ 17 / STYLE

Anthropic's Protocol Style

Looking back at the protocol table in § 12, none of these six protocols is a complete product-grade SDK. They're all minimal specifications:

The pattern is clear: define the interface first, don't build tooling, let the community fill in implementations. Buddy is the latest instance of this pattern—the interface position is staked out; the official firmware is just a reference starting point.

For developers, this means two practical things:

1. Don't wait for Anthropic to ship complete tooling—their protocols are interface specifications, not platforms; ecosystem building is up to you

2. Build early, gain advantage—every protocol's early ecosystem lacks good implementations; this window won't stay open forever

CODA

These limitations aren't oversights; they're design decisions—approvals have friction, the protocol is simple enough to fork, the device can't bypass the human.

The reason this protocol is worth reading isn't what it can do now, but that it stakes out a position no previous protocol occupied: the interface between an agent and physical proximity hardware. This position is currently empty, and the official implementation is just a starting point.

CLAUDE DESKTOP BUDDY · Duology
FIELD NOTE / № 01 — Product Perspective

Value

Why Buddy matters, what UX trend it points to · Status table + a day narrative + action gradient

▢ Published
DEEP DIVE / № 01 — Technical Perspective

Protocol Deep Dive

Protocol teardown + design analysis + protocol stack positioning + future predictions · Full picture from BLE to agent-hardware communication

▣ Currently reading