A connected-node list looks like an inventory, and it is — but an inventory of identities at a moment, not a CMDB of everything that’s ever touched your hub and not a promise about the plant behind the node. Knowing what each field proves is what turns a status screen into an operations tool instead of a Rorschach test.
This guide covers the connected-node inventory in HUBaaS: what VMAC, certificate subject/serial/expiry and last-activity each tell you, how replica aggregation affects what you see, the difference between node identity and a temporary network address, and how to triage an unfamiliar entry. Every node, VMAC and timestamp here is invented.
Where HUBaaS fits
HUBaaS is Hexomation’s managed BACnet Secure Connect service: per site, one primary hub, optional warm standby, and an optional hosted supervisory node — SC only, with no native field-protocol interfaces. The connected-node inventory is the hub’s view of which node identities currently hold sessions.
Scope matters first: this is SC node state — the nodes accepted by the hub (hub- or enterprise-issued) and the state of their connections. It is not discovery of downstream BACnet objects (that’s the supervisory node’s job where enabled) and not a permanent asset register. Feature availability follows the product plan and version.
The baseline habit that makes the inventory powerful: know which VMACs should exist on your site before the screen surprises you — a connected-node row is only anomalous against a list of what’s expected.
The fields and what they prove
Each row carries a small set of facts. VMAC is the node’s SC network identifier — the key the row is keyed on, and a useful correlation handle — but it is not a permanent cryptographic identity or an ownership proof: it can change or be reused with configuration and lifecycle events, so correlate it with the certificate fields and your commissioning records rather than trusting it alone. Connected reports whether a session currently exists — a point-in-time state, not a history. Last activity is the timestamp of the last message the hub received — evidence of when the node last spoke, not when its certificate was issued, not whether its data is fresh, and not proof a healthy plant sits behind it.
The certificate fields — subject, serial, and not-after — tie the connection to the issued identity, and they can be absent on a row. One caveat: subject and serial alone do not unambiguously identify a certificate across issuers — different issuers can emit colliding serials — and the row does not surface an issuer field, which is an explicit limitation; for an unambiguous association, match serial and issuer against your issuance records. Remote address is the network endpoint the connection arrived from — useful for spotting anomalies, but it’s an address at a moment, not a stable ownership identifier: DHCP, NAT and mobility all make it transient.
Read the fields together, not in isolation. A VMAC you recognize with a certificate you issued and recent activity is a quiet “expected.” Any one field off — familiar VMAC on an unexplained address, or an issued-looking subject on a VMAC your records don’t know — is a triage item, and the row is the starting point, not the conclusion.
Aggregated, not historical
The inventory merges node state across replicas: each pod is polled, and rows merge by VMAC choosing the freshest activity — so a standby-enabled hub shows one row per node identity even when its session sits on a specific replica. That’s a current-state merge, not a per-replica history and not a CMDB — if a pod read fails, the previous snapshot stays in place rather than showing a hole.

Refresh is asynchronous with an adaptive cadence — don’t build a mental model that says “this screen is real-time.” A node that just connected may take a moment to appear; one that just dropped may look connected briefly. For decisions that matter, treat the inventory as a recent photograph, not a live feed.
It also isn’t a forensic record: the merged view tells you which identities hold sessions now, not the full history of every node that ever enrolled. If you need historical node lifecycle — who connected when, for how long, across which replicas — collect and verify separate lifecycle evidence; do not assume the available logs cover everything.
An unfamiliar row is a question, not a verdict
The triage that works on an unexpected entry: is the VMAC one your commissioning records say should exist — remembering it can change with lifecycle events? Do the certificate subject and serial match an issued leaf — and can you confirm the issuer from your records, since the row doesn’t surface it? Is the remote address consistent with where that node lives — or genuinely unexplained? Each field narrows the answer differently.

Two traps deserve their own callouts. Duplicate-looking rows with similar subject labels are usually distinct VMACs — similar names don’t merge identities; the dedup logic works on VMAC, not on text that looks alike. And a stale last-activity timestamp has competing readings — the node may be quiet but connected, disconnected, or the row may be an old snapshot left by a failed pod read; the timestamp alone doesn’t say which.
The honest escalation order: check the enrollment record for the VMAC, compare certificate fields against what was issued, assess the address against where the node should live, and only then decide the row is anomalous — an unfamiliar row is a question to resolve, not an intruder to evict reflexively.
The synthetic snapshot
Picture an invented inventory for a moment — VMACs and subjects synthetic, nothing real. One row: a VMAC you recognize, a certificate subject matching your leaf convention, recent activity — quiet, expected, unremarkable. A second row: a different VMAC with a subject label suspiciously similar to the first — “AHQ-F2-Controller” versus “AHQ-F2-Controller-B”. Similar text, distinct identities; the merge keeps them separate because it keys on VMAC, not on how alike the names look.
A third row: a node whose last-activity timestamp is old. Two honest readings compete — it disconnected and the row lingers, or a replica read failed and left the previous snapshot in place. The row itself doesn’t say which; that’s the point of checking rather than assuming either.
What the snapshot deliberately doesn’t show: no verdicts, no colors, no “this one is bad” marking — the rows are evidence to interpret, and the interpretation is the operator’s work, not the table’s. The figures echo that: boxes unchecked, fields annotated with limits.
Identity, not downstream truth
The inventory’s honest limits are the article’s recurring point: a connected node is a session with an identity — it says nothing about what the node can see downstream, whether the points it monitors are healthy, or whether the plant behind it is even real. Those are supervisory questions, and the inventory answers none of them.
Likewise, disconnect and revoke are actions taken on a row, not properties of it — a one-shot disconnect drops a session without banning the node (the reconnect is allowed to happen), while exclusion is a separate revocation matter. This article reads the inventory; the lifecycle actions have their own guides.
That boundary matters for interpretation too: a disconnected node reappearing is the system working as designed, not an anomaly — the disconnect was a session drop, and the node reconnecting is the expected follow-through. Whether it should have reconnected is a different question that belongs to the trust and revocation layers.
The fair alternative
Where the console inventory earns its place is operations: one view of which identities hold sessions, with the certificate and activity context attached — versus correlating certificate files, connection logs and node records manually. Where a fuller system fits better is asset management: ownership, location, lifecycle and warranty are richer records than a session table ever was.
The honest boundary holds: if your question is “what identities are connected and what does each prove,” this is the tool; if your question is “what do we own and where does it live,” that register lives elsewhere.
And keep both questions in reach anyway — the inventory answers the operational one fast, and the asset register answers the ownership one properly; conflating them is how a session table gets mistaken for a source of truth it was never designed to be.
Read the inventory as evidence
The short version: VMAC is the row key, connected is a moment, last activity is when the node last spoke — and none of it proves a healthy plant or a permanent record. Triage unfamiliar rows against commissioning records and certificate consistency (issuer included), treat remote addresses as transient context, and remember the refresh is asynchronous.
Once read that way, the inventory becomes genuinely useful — a current-state session ledger that tells you who’s talking, when they last did, and what the row proves — rather than a screen that invites you to infer more than it knows.
To baseline expected SC nodes on your deployment, review the managed service at HUBaaS.io, and see the managed hub for the service context this inventory sits inside.