Using Home Assistant with Manifold
Summary: Manifold is evolving into a proper framework for building meshes of picos, and Home Assistant gives those meshes an interface. A new Home Assistant integration proves out three pieces at once: an OAuth workflow on the pico-engine that lets outside software into the mesh on the owner’s terms, a mature interface rather than a custom one, and a pattern that lets specialized communities extend the platform.
The original Manifold (which was a replacement for the old SquareTag) gave a person a place to gather their connected things under their own control, but it needed its own web application to provide the UI and manage accounts. Rebuilding Manifold on version 1.5 of the pico engine turned it into a framework for building meshes of picos. But that mesh is only useful if outside software can reach it, if the owner has an interface that is easy to use, and if specialized domains can extend it without forking the platform. Those are three separate problems, and a Home Assistant integration was how I proved I had an answer to each one.
This work sits directly on top of the last two things I wrote about. In Manifold API and Sensor Network: Two New Repos I rebuilt Manifold as a framework and rewrote the sensor network as an example that runs on it, and I flagged a Home Assistant integration as the obvious next step. Then in Identity for the Pico Engine I added OAuth to the engine and said the Home Assistant layer would be the first real exercise of that identity work. This post is where those two threads meet.
I’ll take them in the order they build on one another: an OAuth workflow that lets an outside application into the mesh, Home Assistant replacing the custom Manifold interface, and a pattern that lets a domain like a sensor network add its own behavior on top. Each of the three are working now. One thing still doesn’t, and I’ll come to that.
Letting an Application In
Version 1.5 of the pico engine finally moved identity into the engine itself, including OAuth for external applications and webhooks; I described that design earlier in Identity for the Pico Engine. Home Assistant was the first real client I pointed at it. When someone adds the Manifold integration, Home Assistant runs the OAuth flow and comes away with a token it can use to access the mesh. This allows each mesh owner to grants access deliberately using a token that is scoped to what the application should see, and that the owner can revoke later.
An Interface I Didn’t Have to Build
The old Manifold answered the interface question by building a web application: accounts, dashboards, notification screens, all of it written and maintained as custom code. Home Assistant already solves that problem for a large community of users, and its open source. So rather than ask owners to learn another dashboard, Manifold now appears inside one that many of them already run.
Things and communities show up as Home Assistant devices, and Manifold’s notifications reach the owner through a dedicated channel that the homeassistant ruleset creates on install and forwards enabled alerts to. Home Assistant is already where many people run their home automation and sensors, and a Manifold mesh drops into that same surface, adding picos to HA, each with its own logic and its own relationships. Reusing a mature system beats maintaining a thinner copy of it. The time I would have spent on yet another dashboard goes to other projects.
Room for Specialized Communities
A platform is only generative if other people can build on it without asking permission, and the third component demonstrated that idea. The sensor network I rebuilt as a Manifold example needed sensor-specific behavior in Home Assistant, not just the generic view of things and communities. So it ships a companion integration, pico_mesh_sensor_network, that declares the Manifold hub as a dependency and attaches sensor entities to the thing devices Manifold already created. The pattern is small: domain rulesets in the repo root, a companion component beside them that depends on the hub, and a stable surface to import from. Any Manifold community can follow it, which is exactly what I wanted to demonstrate.
What Still Doesn’t Work
One piece of the old Manifold has not made the trip yet. SafeAndMine, the application that started this line of work, depended on physical tags: an NFC sticker or a QR code on an object that resolves through a tag registry to the pico that represents that thing. The registry is in place and things can register against it, but scanning a tag and following it to the right pico does not yet work end to end. Until that path is solid, Manifold can model your things but it cannot let a stranger scan the tag on your lost backpack and reach you. That is the next thing to finish.
Manifold has evolved from a product with its own screens to maintain into a foundation for building meshes of picos that can sit at the network edge. What makes that real is the architecture holding together: identity that lets outside software in on the owner’s terms, an interface in a system people already trust, and an extension pattern that invites other domains to build. The tag path still has to land before I would call the old Manifold fully replaced. But the important parts are working now.
Photo Credit: A Home for Your Pico Mesh from ChatGPT (public domain)
