Creative · Community report
Connect a custom gadget to your agent
Having bought a Cardputer, a small ESP32 handheld, to build an interface for another agent, one person on X connected it to Muse with its gadget SDK instead and had it working the day it arrived. That is one device, so this page shows how to connect a custom gadget and check yours is supported first.
What you can get
What it is
Connected hardware gadget
A physical ESP32-based gadget connected to your Muse account, confirmed working, ready for you to define what it actually does.
It came back right when
- The gadget successfully pairs with your Muse account.
- Basic two-way communication between the gadget and Muse works as expected.
- You understand what the gadget is now able to do versus what it could do before.
The checks are editorial, not from the source.
- Confirm hardware
Check your device is ESP32-based and SDK-compatible.
- Flash the SDKStops for your approval
Set up the device per the SDK's own instructions.
- Pair with MuseStops for your approval
Connect the gadget and test basic communication.
- Define what it doesStops for your approval
Build and test the actual interface or interaction, scoped and reviewed.
Editorial, not from the source
Works when
- You already have, or are buying, ESP32-based hardware.
- You want a physical, tangible interface to your agent rather than only a phone or chat window.
- You're comfortable with basic hardware setup (flashing, wiring) separate from the Muse side.
Does not work when
- You don't have ESP32-compatible hardware and aren't looking to buy any.
- You need something that works the moment you open the box with zero setup; the report describes a same-day connection, not a zero-setup one.
- You were hoping for an officially documented, supported device list; this is one person's report with one device.
Connect a custom gadget: review template
| Setup step | What it's based on | Status |
|---|---|---|
| [Device and SDK version] | [Your hardware + Muse's SDK docs] | [Confirmed compatible] |
| [Pairing test] | [Basic connection check] | [Working] |
| [First task or interaction] | [What you define] | [Scoped and tested] |
The source case
On X, @arturoleon reports buying a Cardputer, a small ESP32-based handheld, to build a tiny custom interface originally for a different personal agent. Then @Muse released its ESP32 gadget SDK, which saved me a bunch of work, so I connected it to Muse instead. I didn’t expect to have it working on the day it arrived. This is one report, checked on 2026-10-09, of one specific device; it does not establish that any other ESP32 or microcontroller device will connect the same way.
A public report by someone outside this library. Not independently reproduced here.
From the source
Source excerpt
I bought this Cardputer to build a tiny interface for my Hermes agent. Then @Muse released its ESP32 gadget SDK, which saved me a bunch of work, so I connected it to Muse instead. I didn’t expect to have it working on the day it arrived.
Quoted from the original posts. Not written by this guide, and not a result produced here.
Suggested prompt
Bring An ESP32-based device (such as a Cardputer or similar board), Muse's ESP32 gadget SDK. Acts Communicates with a physical ESP32-based gadget once connected. Source community report, checked 2026-10-09.
Written by this guide as a starting point, not quoted from the source. Your edits stay in this browser.
Other ways to ask
Editorial rewrites of the brief above, for a different emphasis. Copy them separately.
What you need
Editorial, not from the source
You supply
- An ESP32-based device (such as a Cardputer or similar board)
- Muse's ESP32 gadget SDK
Connected
- The physical gadget itself, connected to power and to your network or Muse account
- Developer/SDK access for flashing or configuring the device
Approved by you
- Approval before the gadget is given any account access beyond basic pairing
How to try it
Editorial, not from the source
- Confirm your device uses the ESP32 chip (or a compatible board) and get Muse's gadget SDK.
- Flash or configure the device with the SDK before connecting it to your Muse account.
- Pair the gadget with Muse and test basic communication before building anything further on top of it.
- Treat the first connection as a starting point: the report describes the device working the day it arrived, not a finished custom interface.
Confirm the hardware before you confirm the task
The one report behind this page is specific about one piece of hardware: a Cardputer, a small handheld built on the ESP32 chip. It does not say whether Muse's gadget SDK works with other ESP32 boards, sensors, or home-built circuits, only that this one device connected the same day it arrived. Before treating "connect a gadget" as a settled task, check the SDK's own documentation for which boards and configurations it actually supports. ESP32 is a popular, affordable chip used in a wide range of inexpensive devices, so there's reason to expect some flexibility, but one report about one handheld is not confirmation that your specific board, sensor, or project will behave the same way once you plug it in.
A same-day connection is not the same as a finished project
The report says the gadget was working the day it arrived, which describes the hardware pairing with Muse, not a completed custom interface doing something useful. The author had originally built the device for a different agent before switching it over to Muse's new SDK, which suggests the pairing step itself was comparatively quick. What happens after that, building an actual interface, assigning it a purpose, wiring it into other parts of your setup, is not covered. Treat a successful connection as the starting point for a project, not the project itself, and plan for the usual hardware work (flashing, debugging, iterating on what the gadget actually does) that a single post about a same-day pairing doesn't capture.
Keep the gadget's access scoped while you learn what it can do
A physical gadget that talks to your agent is a new access point into your account, and the report doesn't describe what permissions or data the device ended up with once connected. Until you know exactly what it's capable of requesting or triggering, it's worth treating any gadget connection cautiously: start with read-only or low-stakes interactions, and only expand what the device can do once you've tested it and understand its behavior. This is ordinary hardware-project caution rather than anything specific to this report, but it matters more with a device built once and left running than with a chat window you're actively watching.
Open Muse to try it. That is the product's own site; this guide is not part of it.
Limits and confirmation points
Limits to confirm
- One report, about one specific device (a Cardputer); it does not show how other ESP32 boards, sensors, or custom hardware behave with the SDK.
- No detail is given on what the gadget actually does once connected, only that it connected and worked the same day.
- Hardware setup (flashing, wiring, power) is not described in the report; you'll need the SDK's own documentation for that.
- The report doesn't say what the original interface the device was built for was for, so it's unclear how much of that earlier work carried over.
Stop and check
Editorial, not from the source
- Before buying hardware: confirm it's ESP32-based and compatible with Muse's SDK.
- Before connecting: have the SDK installed and the device flashed per its own instructions.
- Before relying on it: test basic communication rather than assuming the first connection means everything works.
If it goes wrong
Editorial, not from the source
- The gadget won't pair with Muse after flashing the SDK
- Check the SDK's own setup documentation for flashing and firmware version requirements; this report doesn't cover troubleshooting steps.
- You're not sure if your specific board is supported
- This report only confirms one device (a Cardputer). Check Muse's own SDK documentation for a supported hardware list before buying anything.
- The gadget connects but you don't know what to do with it next
- Start with basic communication tests before building a custom interface; the report doesn't describe what was built after the initial connection.
Common questions
Does Muse support ESP32-based hardware?
One user reports that Muse released a gadget SDK for ESP32 devices and successfully connected a Cardputer, a small ESP32-based handheld, the same day it arrived. This is one report about one device, not a full supported-hardware list.
What exactly can a connected gadget do?
The report doesn't say. It confirms the device connected and worked, but gives no detail on what tasks or interactions it performs once paired.
Do I need coding or hardware experience?
The report doesn't specify the author's skill level, but mentions flashing the SDK onto the device, which typically requires some comfort with hardware setup. Check the SDK's own documentation for exact requirements.
Will any ESP32 board work, or only specific ones?
Only one device, a Cardputer, is confirmed in this report. Check Muse's SDK documentation directly for which boards are actually supported before buying hardware.
What access does the gadget get once connected?
The report doesn't say. Treat any new connected device cautiously and start with limited access until you understand what it can request or trigger.
Next
Related to this task
More in Creative
Get recurring task recommendations — ask your own agent to check for relevant updates.