Building Management System (BMS)

What if a smart building could maintain its own state without constantly recomputing everything?

Modern Building Management Systems (BMS) coordinate thousands of interconnected data points: HVAC, temperature, occupancy, energy consumption, lighting, security, and environmental sensors.

Traditional architectures often rely on event buses, message brokers, cloud services, and manually coordinated automation rules.

But a building is more than a collection of events.

It’s a graph of dependencies.

What if the building itself were a reactive namespace?

With .me, an open-source reactive knowledge graph kernel, building state can be represented through paths:

me.building.floor12.zoneA.temperature(24);
me.building.floor12.zoneA.occupancy(0);
me.building.floor12.zoneA.energy.peakRate(true);

Instead of coordinating every state update through event listeners, relationships can be declared:

me.building.floor12.zoneA["="](
  "coolingRequired",
  "temperature > 25 && occupancy > 0"
);

When a sensor changes, the kernel identifies and recomputes the affected dependencies.

One mutation. Only the necessary recomputation. O(k).

Why Does This Matter for Smart Building Infrastructure?

A reactive dependency graph creates opportunities for:

• Edge Computing: Maintain operational state locally, reducing unnecessary cloud processing.

• Energy Optimization: React to occupancy, temperature, and energy pricing changes.

• Incremental Recomputation: Update affected dependencies instead of recalculating unrelated state.

• Explainability: Inspect derived values and their dependencies using me.explain().

• Declarative Automation: Replace manually coordinated state-update handlers with explicit relationships.

Imagine a building with 100,000 interconnected nodes.

A temperature change in one room shouldn’t require reevaluating every unrelated room.

But when a shared dependency changes, such as an energy policy affecting every zone, the kernel must propagate that change correctly.

Both scenarios matter.

Can a Reactive Kernel Handle 100,000 Dependencies?

The .me Extreme Fan-Out demonstration explores exactly this problem.

One root mutation triggers recomputation across 100,000 dependent nodes.

The objective isn’t to avoid necessary work. It’s to perform the work required by the dependency graph without unnecessary recomputation.

Explore the Extreme Fan-Out Benchmark

From Smart Buildings to Smart Cities

The same architectural principles extend beyond individual buildings.

Ports, logistics networks, energy infrastructure, transportation systems, and entire cities contain interconnected operational states.

Instead of treating these systems as isolated streams of events, we can model their relationships as reactive knowledge graphs.

Explore the interactive demonstrations:

Smart City Demo — Veracruz Port

Smart Cities — AI Decides

.me Technical Documentation

The Bigger Idea

A smart building shouldn’t just collect data.

It should understand how its data is connected.

Sensors provide observations. Dependencies define relationships. Reactive computation keeps derived knowledge current.

That’s the architecture we’re exploring with .me.

Don’t just connect your sensors. Connect their meaning.

Open Source: https://github.com/neurons-me/.me

neurons.me — Own Your Intelligence.