If you have bought a smart plug or light bulb recently, you have probably seen the Matter logo. Matter is an application-layer standard, backed by most of the major platform companies, meant to let devices from different manufacturers work together without a separate app and cloud for each. Thread is the low-power wireless mesh network many Matter devices use to talk to each other. Together they replace a fragmented landscape with something interoperable, and their security model is a real improvement over the ad-hoc encryption that came before. Understanding it also makes clear what it does not do.
Two Layers, Two Jobs
It helps to keep Matter and Thread separate, because they operate at different layers. Thread is the network: a low-power, IPv6-based mesh where devices relay for each other so the whole home stays connected without every device reaching a central hub directly. Matter is what runs on top: the language devices use to describe themselves and be controlled, plus the commissioning and security model that decides which devices are allowed to join and talk.
Thread traffic is encrypted at the network layer using a shared network key, so a neighbor cannot passively read your mesh's packets off the air. Matter then adds its own security on top, so that even within the network, control of a device requires proper credentials. The layering means a compromise at one level does not automatically grant control at the other.
Thread encrypts the local mesh so outsiders cannot read it. Matter uses per-device certificates and secure commissioning so only authorized controllers can operate a device. Both are solid engineering for the local-control problem. Neither is a promise about what a manufacturer's cloud does with your data.
Device Attestation: Proving a Device Is Real
One of Matter's better ideas is device attestation. Every certified Matter device ships with a manufacturer-issued certificate, rooted in a chain the standard's certification body oversees. When you add a device to your home, the commissioning process checks this certificate to confirm the device is a genuine, certified product rather than a counterfeit or a malicious lookalike. This is conceptually similar to how certificate authorities underpin trust on the web, applied to hardware.
Attestation matters because the smart home has historically been a soft target, full of cheap devices with weak or nonexistent authentication. Requiring a verifiable certificate raises the floor. It does not make devices perfect, and attestation says nothing about software quality or a vendor's data practices, but it closes off a category of impersonation and counterfeiting attacks that plagued earlier ecosystems.
Commissioning: The Moment of Trust
Adding a device, called commissioning, is where a lot of the security lives. Matter uses a setup code, typically a QR code or numeric string on the device, to establish an initial secure channel using a password-authenticated key exchange. From there the device is issued credentials for your specific home fabric, the trust domain that ties your devices and controllers together. After commissioning, control is limited to members of that fabric.
The setup code is the root of this trust, which is why it should be treated like a key. Anyone with physical access to the code during setup, or a photo of it, has the material needed to commission the device. It is a reasonable design, but it locates a real piece of your home's security on a small printed label, which is worth remembering when you photograph or share device packaging.
What the Standard Does Not Address
Here is the honest limit. Matter and Thread secure the local control path. They do not govern what a device manufacturer's cloud collects, retains, or shares. A Matter-certified camera can be secure on your local mesh and still stream usage data, telemetry, or footage to a vendor cloud under terms you never read. The standard is about interoperability and local security, not about restraining the business models that make so many smart devices privacy problems in the first place.
| Concern | Addressed by Matter/Thread? |
|---|---|
| Neighbors reading your mesh | Yes. Thread encrypts network traffic with a shared key. |
| Counterfeit or rogue devices | Largely. Device attestation checks a manufacturer certificate at commissioning. |
| Unauthorized control | Yes. Only members of your fabric can operate a device. |
| Vendor cloud data collection | No. Out of scope. The standard says nothing about what the manufacturer's cloud does. |
| Traffic-pattern inference | No. Even encrypted, the timing of device events can reveal occupancy and habits. |
Matter and Thread solve the interoperability and local-security half of the smart home well. The half they leave untouched, what vendors do with the data once it leaves your walls, is the half that made smart homes a privacy story to begin with.
Local Control Is the Real Privacy Lever
The most privacy-protective thing about the Matter ecosystem is not a cryptographic feature at all. It is that Matter enables local control, letting devices function through a home hub without a round trip to a vendor cloud for every action. A device that can be fully controlled locally, and that you can firewall off from the internet, sidesteps most of the data-collection problem by construction. The traffic-pattern inference risk remains, since even encrypted event timing can reveal when you are home, but local-only operation is the strongest lever an individual has.
If you are building out a smart home and privacy matters to you, the practical guidance follows from the standard's boundaries. Prefer devices that support local control, segment your smart devices onto their own network segment, and treat the vendor's data policy as a separate question from whether the device is Matter-certified. Certification tells you the device is interoperable and locally secure. It tells you nothing about the cloud behind it.
Where Haven Fits
Haven does not make smart-home devices, but the lesson translates directly to communication. A standard can secure the transport and the local trust model impeccably and still leave the important question, what the operator can see, entirely open. That is exactly the gap we design against: Haven's messages are end-to-end encrypted so that the service running the infrastructure cannot read them, which is the communication equivalent of a device that works without phoning home.
Matter and Thread are a genuine step forward for a category that badly needed open standards and real device security. Just read them for what they are: a fix for interoperability and local control, not a fix for the surveillance economics of connected devices. Those you still have to manage yourself, device by device.