How do Home Assistant automations work behind the scenes? Is there any kind of trigger optimization?

Configuration
1

HA is quite flexible. You can create a lot of different kinds of automations,

But I am curious how it handles all the triggers behind the scenes? One could have a lot of automations with a lot of triggers that could be very inefficient.

For example, a user could have:

  • multiple automations that run on some timer (like every minute/hour/etc.)
  • multiple automations that do the same thing but for different device (e.g. one automation for living room light and another one for bedroom light) instead of a single automation that triggers on multiple things and then uses if/then/choose to decide what action to take

I am new to HA but I am sure there are other examples of potentially inefficient automations.

How does HA handle these? Is it doing any kind of optimization? Or does it run things exactly how the user has and so the user should try to optimize their automations (at the risk of making them complex/confusing).

2

I’d say don’t think about it.
If you find that HA does not do things in time then upgrade the computer instead.
Micromanaging it like this will cause your automations to be unreadable.
Keep one automation to one device or one action, or whatever feel natural at the time. But for the sake of unloading the CPU it’s not worth making any changes unless you are doing something completely wrong like

Why would you need that?

1 Like
3

The automation engine looks at your automation triggers, then sets up a sort of watchman in charge of following the event bus in Home Assistant (and other things, like timers and REST endpoints).

Each trigger has a target condition which may depend upon one or more entities, attributes or other types of data collected by HA. Particularly for triggers depending on entity states, this is done using a dependency graph (trigger A depends on entity E, and so on and so forth). Ultimately, this lets the automation engine know exactly which events in the bus affect which triggers.

As events go through the bus, the watchman looks at the dependency graph. And then, using that graph, decides which triggers have to be recomputed due to the bus event it is processing, to see which triggers need to fire.

Because of the dependency graph, this computation happens very efficiently and very quickly. A great deal of why it is efficient is due to the dependency graph limiting what exactly needs to be evaluated based on what triggers are affected by a specific event. Another reason it is efficient is that when the automation engine recomputes each affected trigger, it never actually talks to an external subsystem to retrieve information — it’s always local data access (for evaluating most triggers, the engine really only needs to look at the specific event being processed).

In concrete terms: you have an automation that depends on a motion sensor in your bathroom, and another that depends on the water flow of your home. The triggers for your motion sensor automation only get evaluated when the motion sensor changes state. The triggers for the water flow automation only get evaluated when water flow changes. You could conceivably have 10,000 automations, but because only one of them gets evaluated, you only pay for the overhead of that one trigger, which is in the microseconds or nanoseconds range. The lookup from event to trigger and from trigger to automation is constant time, and so is the reevaluation of the trigger.

Admittedly, I don’t really have a full understanding of the engine because I haven’t read the source code of that part of HA in full. But you really have to marvel at what an amazing piece of technology it is.

In general, you don’t need to think about how efficient your automations or your triggers have to be. You just have to be careful not to demand that the automation engine (your trigger) is monitoring a ton of entities or monitoring very noisy entities.

4 Likes