Post cover image

April 20, 2026

Anthropic Just Open-Sourced the Claude Hardware Buddy

First MCP, then Agent Skills and now BLE Hardware. Anthropic is leading the way.

By Marco Kotrotsos

6 min read

Three weeks ago, I published an article titled "Anthropic Is Building a Physical Device. It's Called Buddy, and It's Already in the Code." We found Nordic UART UUIDs, firmware flashing infrastructure, telemetry fields, and the string "Build your own device" buried in Claude's desktop app binary.

Now it's on GitHub. Every prediction we made from the binary was correct. The BLE UUIDs match. The telemetry fields match. The maker-friendly positioning matches. What we couldn't determine from the code, the physical form factor and the character system, turns out to be more fun than expected.

What you need

An M5StickC Plus. That's the reference hardware: a tiny ESP32 board with a 135x240 color display, two buttons, an accelerometer, and USB-C charging. Available for around $20–30 from most electronics retailers.

You also need:

  • PlatformIO (the firmware build tool)
  • Claude for macOS or Windows with developer mode enabled
  • A USB-C cable for flashing

That's it. No soldering. No breadboards. No custom PCBs. Flash the firmware, pair over Bluetooth, and you have a desk companion that's wired into everything Claude does.

Flash and pair in five minutes

Clone the repo:

git clone https://github.com/anthropics/claude-desktop-buddy
cd claude-desktop-buddy

Flash the firmware:

pio run -t upload

If the device was previously flashed with something else:

pio run -t erase && pio run -t upload

In Claude Desktop, enable developer mode: Help, Troubleshooting, Enable Developer Mode. Then Developer, Open Hardware Buddy, click Connect, and pick your device from the BLE discovery list. macOS will ask for Bluetooth permission once.

The device auto-reconnects whenever both sides are awake. No re-pairing needed.

What happens on the device

Seven animation states, each triggered by what Claude is actually doing:

Sleep. Bridge disconnected. Eyes closed, slow breathing animation. The device is a paperweight until Claude is running.

Idle. Connected but nothing happening. The character blinks, looks around. Waiting for you to start a session.

Busy. A session is actively generating. The character sweats, works frantically. You can see at a glance that Claude is doing something without checking your screen.

Attention. A permission prompt is waiting. The character goes alert, the LED blinks. This is the killer feature: you're getting coffee, your phone buzzes, you glance at the Buddy on your desk and see it needs an approval. Walk over, press A to approve or B to deny. You never opened your laptop.

Celebrate. Every 50K tokens, confetti and bouncing. A small dopamine hit for your token burn rate.

Dizzy. Shake the device. Spiral eyes, wobbling. No practical purpose. Pure fun.

Heart. Approve a permission prompt in under 5 seconds. Floating hearts. The device rewards fast approvals.

The permission buttons are the real feature

The character animations are charming. The actual utility is the physical approve/deny buttons.

Claude Code and Cowork constantly pause for permission: file writes, bash commands, tool calls. If you're at your desk, you click through the dialog. If you stepped away, the session blocks until you come back.

With Buddy, the approval prompt shows on the device screen. The hint field tells you what's being requested: "Bash: rm -rf /tmp/foo" or "Edit: src/auth.ts". Press A (front button) to approve. Press B (right button) to deny. The decision routes back to Claude over BLE, and the session continues.

This means Claude can keep working while you're making coffee, talking to a colleague, or across the room. The device is a physical remote control for AI permission management. The form factor happens to be a cute desk pet, but the function is industrial: untethered approval for autonomous agents.

The protocol, for people who want to build their own

The reference implementation is an ESP32 project. The protocol is hardware-agnostic. Anything that speaks BLE Nordic UART Service can be a Buddy.

The wire protocol is JSON over BLE serial:

Heartbeat snapshots flow from Claude to the device every 10 seconds (or on state change):

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

Permission decisions flow from the device back to Claude:

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

Status responses report device health:

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

That's the core. Device advertises BLE with a name starting with "Claude," desktop discovers it, JSON flows back and forth over NUS. The full spec is in REFERENCE.md.

Five project ideas that aren't a desk pet

The reference implementation is a desk pet on an M5StickC Plus. The protocol supports anything with BLE. Here are five builds that use the same API for something different.

1. The approval traffic light

Three LEDs: green (idle), yellow (busy), red (waiting for approval). Mount it on top of your monitor. When red lights up, you know Claude needs you. Tap a button to approve. Total BOM: $8 in parts.

Read waiting > 0 from the heartbeat. When true, light the red LED and listen for a button press. On press, send {"cmd":"permission","id":"...","decision":"once"}. That's the entire firmware.

2. The token burn meter

An analog gauge (servo motor + printed dial) that shows your daily token consumption. The needle sweeps from 0 to your daily budget. Mount it next to your monitor like a speedometer.

Read tokens_today from the heartbeat. Map it to a servo angle. Update every 10 seconds. Add a red zone on the dial for your "maybe slow down" threshold. Satisfying and genuinely useful for Max subscribers watching rate limits.

3. The session ambient display

An e-ink display (Waveshare 2.13" or similar) that shows the last few transcript entries. Low power, always on, no backlight. Set it next to your keyboard. Glance over to see what Claude just did without switching windows.

Read the entries array from the heartbeat. Render the last 5-6 lines on e-ink. Refresh only when content changes (e-ink is slow, so diff the entries). Battery lasts weeks because e-ink only draws power on refresh.

4. The CI/CD approval puck

A single large button in a 3D-printed enclosure. Sits on your desk. When it lights up, Claude needs a permission. Smack the button to approve. That's all it does.

The simplest possible Buddy implementation. One NeoPixel ring around the button for status (green pulse = idle, red pulse = waiting). One button. One message type. Perfect for anyone who finds the desk pet too cute for their engineering aesthetic.

5. The wearable notification band

An nRF52 wristband (or a cheap fitness tracker reflashed) that vibrates when Claude needs approval. Tap the band to approve from wherever you are, kitchen, meeting room, garden. The BLE range on nRF52 is good for about 30 meters indoors.

Read the heartbeat, vibrate on waiting > 0, send approval on tap. The band doesn't need a screen. A vibration pattern is enough: two short buzzes for "approval needed," one long buzz for "session complete."

Custom characters

The GIF character system is fun. You can design your own desk pet with custom animations for all seven states, package it as a folder of 96px-wide GIFs with a manifest, and push it to the device over BLE.

{
  "name": "bufo",
  "colors": {
    "body": "#6B8E23",
    "bg": "#000000",
    "text": "#FFFFFF"
  },
  "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"
  }
}

The folder size limit is 1.8MB. Use gifsicle --lossy=80 -O3 --colors 64 to compress. Drag the folder onto the Hardware Buddy drop target in Claude Desktop, and it streams to the device over BLE.

There are already 18 built-in ASCII characters if you don't want to make GIFs. Cycle through them from the device menu. Each has all seven animation states.

We found it in the binary. Now it's real.

When we reverse engineered Claude's desktop app, the Buddy infrastructure was one of the most surprising findings. A hardware BLE stack inside an AI company's chat app. Nordic UART UUIDs. Firmware flashing code. Telemetry fields for battery, heap, and uptime. The strings "Build your own device" and "Connect maker devices to Claude."

Three weeks later, it's an open-source GitHub repo with a documented protocol, a reference implementation, and a character system that lets you put a custom animated pet on a $25 ESP32 board that physically approves your AI's actions.

I don't know if Anthropic will ever sell a consumer hardware product. But they just gave makers everything they need to build one, following their MCP and Skill's play. The protocol is clean, the documentation is thorough, and the first project takes five minutes to flash.

If you are a mega nerd like me, and have an M5StickC Plus in a drawer somewhere, go flash it. If you don't, order one. This is the most fun $25 project in AI right now.

The repo: anthropics/claude-desktop-buddy

Three key takeaways:

  1. Anthropic released the Claude Desktop Buddy, an open-source BLE protocol and ESP32 reference implementation that lets makers build physical hardware companions for Claude. We found this buried in the desktop app binary weeks ago. Now it's a real GitHub repo with firmware, a wire protocol spec, and a GIF character system.
  2. The device sits on your desk, shows what Claude is doing in real time, and has physical approve/deny buttons for permission prompts. It celebrates when you hit token milestones, sleeps when Claude is idle, sweats when sessions are busy, and does a dizzy animation when you shake it. It's a Tamagotchi for your AI assistant.
  3. The protocol is the real product. Nordic UART Service over BLE, JSON messages, documented message types. You don't need the ESP32 reference board. Any BLE-capable device, Raspberry Pi, nRF52, custom PCB, can implement the protocol and become a Claude companion. The hardware is the example. The API is the invitation.

Marco Kotrotsos, specializing in practical AI implementation for organizations ready to close the gap between AI hype and AI value. With 30 years of IT experience now focused purely on AI deployment, he works hands-on with companies to turn AI potential into measurable business outcomes.

This article is published in Autocomplete, a Medium publication about real-world AI for practitioners and decision-makers. We're always looking for writers. If you're building with AI and have something worth sharing, reach out.

My free Substack newsletter, also called Autocomplete, can be found here: https://acdigest.substack.com.