Something I've Been Exploring

Share your Projects!
1

Home Assistant has given me an extraordinary place to experiment. Over time, my projects moved beyond individual automations into questions about who is present, why the Home made a decision, what should be remembered, and how technology can remain understandable as the Home changes.

I began sharing those ideas under the name Homes That Behave Well™:

:clapper_board: Homes That Behave Well™ YouTube Channel
Watch the Series

:house: Homes That Behave Well™ Website
Explore the Site

The thought recently occurred to me that the framework might also be useful as an optional Home Assistant integration. I’m actively exploring that idea in the Homes That Behave Well Home Assistant repository:

:wrench: HTBW Home Assistant Integration Repository
View the Repository

I’m exploring a layer that could expose shared APIs for identity, context, explainability, stewardship, and governance, allowing other integrations, scripts, and automations to reuse those capabilities rather than each Home needing to build its own version. Perhaps as building blocks for this community.

This work grew out of many years using Home Assistant, and Home Assistant seems like the right foundation to build this on top of. The community is already doing remarkable work in these areas, often in different and creative ways. I’m not presenting HTBW as the answer. I’m simply sharing an approach that has helped me think differently about my own Home and asking whether it might be useful to others.

I would love to hear what you think.

2

I (think) I do a similar thing.

For some of my more major controls (shades, lights, heating) I have an attribute that tells me why it has done the thing it has done.

For example, the snapshot below shows that my heating thermostat has dropped by 4° (relative to the set schedule) because I have some windows open:
Screenshot 2026-09-05 at 09.02.28

3

Interesting post. (on a side note: I advise you to change the title of the post to something more describing).

I have had home automation for a hobby for over 10 years. I second a lot of what you’re saying. The funny thing is that I do a lot of things ‘wrong’ but leading to interesting findings and approaches.

I have a few premises towards Home Automation that guide me while I went along to see where my experiments would take me:

  • The home should be controllable by a stranger who has no clue how much is automated.
  • If home automation breaks, the home should stay functional.
  • I should not need to fight automations. They should be unintrusive and either work quite well 95% of the time or not interfere.
  • If automations do make mistakes, the user must be able to intervene easily.
  • A home is to complex to be fully rule based. PLC style automation (with rules that suggest ‘always when…’ instead of trigger based) is not going to work in a home. There are too many variables.

But instead of building a well designed, compact, easy to understand system, I did the opposite to see where it took me. If there is a sensor that is fun, add it. If an integration exists that is interesting, add it. Usefullness is not an argument, the more the merrier. It is a hobby and a playground first and foremost. Home Assistant takes that kind abuse remarkably well by the way.

The first interesting result is this: The ideas followed from the abundance of information and things to control, not from a wish to accomplish something usefull. Combining things I had to something more worthwhile. And the bigger the system grew, the better the automations became. But that needed an approach to reduce complexity.

Because I have so much things in Home Assistant, I needed a way to increase information density in dashboards in a way that was still attractive and useable. I built a lot of custom components to combine related data and controls. But that becaume unmaintainable too. I also needed a way to reduce complexity in automations that combined lots of inputs.

One thing I learned was to create lots of entities to reduce complexity and make me understand what happens. For instance: Many of my windows have two window sensors, one for ajar and one for wide open. That is because when ajar, a curtain can still close, but not when the window is wide. I also have automations to tell me if I need to open a window or close it based on inside/outside temperature differences, air quality inside, direct sunlight, positions of shades, etc.

So ultimately I have a template entity for each window which is much richer in information than your average window sensor. It tells how far open it is, if I’d rather need close or open it instead, why that is usefull and maybe even what information led to that conclusion. I have an entity saying when it might be a good time to charge my car, how much time it will take and when I think it will be ready. I also have an entity telling me when I need the car to be charged. The automations reacting on them are small and easy to understand by themselves.

The logic is not all in that entity. I create lots of entities in between to combine information into new information. I for instance have an entity telling me if I produce more sun than I use. I have en entity telling me if the diswasher is waiting to be started automatically if there’s an excess of sun. You get where it takes me. Those entities are pretty self explanatory, and often by combining yet other entities in the way you use functions and variables in programming. Yet they are not functions, they are states. Ready for use 100% of the time, triggering events when the stars align.

I also added attributes to help me reduce the number of custom components I needed for dashboards. I started adding information for presentation in a standardised way. What color/background/icon is most suited to represent its state? So now I have some custom front end components. But they take their cues in a standard way from the entities and their attributes.

Working this way, many entities became self explanatory and about a what I need to know about something in the human domain rather than about what an IOT device is meant to measure or control.

Interestingly enough, my approach is contrary to where Home Assistant seems to be heading. (Partly standardised) attributes are my friend, but HA is moving away from using them and making showing them harder.

Instead Home Assistant is moving focus towards devices. But those devices often represent an IOT thing such as a smart plug, but not a domain thing (something in my home combining a lot of information coming from different IOT devices). Most devices are either a control of a sensor. So unless HA at some point makes it possible to create ones own enriched devices, standardises information inside those rich devices and has components to show those devices as one thing in the UI, this is not helping me in my approach.

It would also require entities to be able to belong to multiple devices if that information is useful in more ways. This is something I now do by referencing other entities in attributes, which is awkward for the user.

4

I really like this example.

What caught my attention is that you’ve effectively answered the user’s next question before they have to ask it. Seeing “15°C” would make me wonder what happened. Seeing “15°C (-4.0) because windows are open” immediately makes the behavior understandable.

That’s one of the reasons I’m so interested in explainability. It isn’t always about AI or complex reasoning. Sometimes it’s as simple as helping the homeowner understand why the system made a decision.

In many ways, that little note may be more valuable than the automation itself because it builds confidence that the home is behaving intentionally rather than mysteriously.

5

This is a fascinating perspective because I think we’re arriving at many of the same conclusions from opposite directions.

You started with experimentation and abundance: if a sensor was interesting, add it; if an integration looked fun, try it. I tend to approach it from governance and architecture first. Yet we’re both describing a progression from raw devices and signals toward higher-level concepts that are meaningful to people.

What really resonated with me was your observation that the automations became simpler as your understanding became richer. Rather than creating larger and larger automations, you created entities that express intent, recommendations, or understanding. “Open this window”, “charge the car now”, and “solar surplus available” are much closer to how people think about their homes than individual sensor values.

Interestingly, your experimentation approach is very similar to how I treat my development environment. I often introduce sensors, integrations, and ideas there long before they ever reach my production home. The difference is that in development I’m asking, “What could this tell me?” and in production I’m asking, “What decision will this improve?” Not everything needs to graduate from one to the other.

I also found your comments about richer entities and explainability particularly thought-provoking. Once we move beyond raw device states and start expressing understanding of the home, the natural next question becomes “Why?” That’s where I think many of us are independently exploring similar territory.

I love the way that the newest release is beginning to bridge that gap in explainability.

to your initial idea - what do you feel an appropriate title would be to get more interaction? I really love the ideas and thoughts of this community.

6

Your comments about creating richer entities really resonated with me because I’ve found myself arriving at similar solutions through experimentation.

One example is our automated shades. My first instinct was to build the automation directly from sensor values and conditions: sun position, weather, brightness levels, room conditions, and so on. It worked, but it quickly became difficult to understand and maintain.

Over time I ended up creating helper entities instead. One helper answers a simple question: “Is the sun directly in this window?” using azimuth and elevation calculations. Another combines multiple light sensors in the living room, dining room, and kitchen into a single composite view of “Is it bright in this area?” That helper can then be considered alongside weather conditions, including the cases where weather reports say “partly cloudy” but the actual light levels tell a different story.

The shade automation itself became much simpler because it no longer needed to understand all the individual inputs. It simply reacts to higher-level concepts. Not to mention the number of automations - one to open, one to close - one set for the south east windows and another for the southwestern. Plus I find that these helpers have also become building blocks for other automations.

In some ways, I think I arrived there the same way you did: by taking the “wrong” path first. Experimenting with sensors, trying ideas, and seeing what information was actually useful. The result wasn’t fewer entities, it was more meaningful entities. The home stopped reasoning about sensors and started reasoning about concepts that make sense to a person.

That’s one of the reasons I found your post so interesting. We seem to be approaching the problem from different directions but discovering many of the same patterns along the way.

7

It was indeed interesting to see your approach as well, leading to similar insights. As for a better title, that is hard. But I think it should reflect it is about how to approach home automation. I almost skipped your post because it could be about anything and that would have been a shame because there’s a lot to learn from it.

The downside to what I did is the sheer vastness of it all. If I stop maintaining it, it is unlikely that any one else will. Maybe I’ll be tempted to build from scratch using only the best bits.

8

Thank you for the feedback on the title. That was actually a deliberate choice on my part. I wasn’t trying to present Homes That Behave Well as the answer or the way to approach home automation. I was hoping to start a conversation about how we think about our homes and learn from the different paths people have taken.

That said, your point is well taken. If someone nearly skipped the discussion because the title didn’t communicate that it was really about approaches to home automation and the lessons learned along the way, then I probably have room to improve.

I also found it fascinating that we seem to have arrived at many of the same insights from opposite directions. Your experimentation-first approach is actually closer to my own experience than the framework might suggest. In my development environment, I regularly add sensors, helpers, and integrations simply to see what information they provide. Many never make it into the production home.

One example is our shades. What started as a collection of sun position, weather, and light sensors eventually became a few higher-level concepts. We now have helpers that answer questions like “Is the sun directly in this window?” using azimuth and elevation calculations, and “Is it actually bright?” by combining multiple light sensors across connected spaces. The shade automation became much simpler because it reacts to those concepts rather than dozens of individual conditions.

In that sense, I think I learned the same lesson you described: the goal isn’t necessarily fewer entities, but more meaningful entities.

Your final point about maintainability also resonated with me. One of the questions that interests me is what happens when the original builder is no longer the one maintaining the system. Can someone else understand it? Can they trust it? Can they evolve it? I suspect that’s where explainability and higher-level abstractions become as important as the automation itself.

Thank you again for taking the time to engage. I’ve learned a lot from your comments already, and conversations like this are exactly what I was hoping the post would encourage.

9

Likewise! And then some extra words to satisfy the minimum post length.

10

  covers 6 of the ten characters required to post, see my next post

11

   

12

I know, but using thise 10 characters to complain is way more satisfying :grinning_face: