SMPTE ST2138 – Yet Another Tree of Commands

Posted on by

An IPv6 packet walks into a bar… and nobody talks to it.

It’s a classic joke in networking, but there’s a deeper, more frustrating truth to it when we look at the current state of media and control protocols. I’ve recently been diving into a Python implementation of the new SMPTE ST-2138 “Chain of Trust” protocol, and I’m struck by a familiar feeling.
Much like that IPv6 packet, ST-2138 is technically robust—structured similarly to OSC or SNMP—yet it feels like it’s shouting into a void. Why? Because in the “protocol wars,” we often mistake complexity for security.

The Great Translation
In building out this implementation, the architectural overlaps are impossible to ignore. If you squint, the barriers between these “competing” standards start to dissolve:
—-MQTT Telemetry: The ultimate mailman. It’s the “topic-based” world where everything is a path, but the payload is often a mystery until you open it.
—-OSC Telemetry: Taking a page from AMWA IS-07, it’s incredibly fast to convert MQTT dialogs to OSC. The nodes and parent tracks follow a logical hierarchy that just works for real-time state.
—-SNMP: It’s the same story. A MIB is essentially just an MQTT topic stripped of its slashes and special characters.
—-VISA/SCPI: Assentially just sending ASCII strings down a tree—it’s just a different dialect of the same conversation.
—-AES70: This is essentially high-speed, strongly-typed SNMP. It brings the discipline we need, but often stays within its own silo.
—-MIDI: Still the outlier with its hard-coded device addresses and channels, yet it remains the “lingua franca” because people actually use it.

The “Chain of Trust” Paradox:
ST-2138 is the only protocol in this list that prioritizes provenance over performance. When you add a “Chain of Trust” to that mix, you aren’t adding 1 bridge; you are forcing the other 5 to adopt a security model they weren’t built for. Sometimes the chain of trust is the user’s problem, or they are simply unconcerned. When we keep inserting middle-ware, translation layers, and new security wrappers between the source and the destination, we aren’t necessarily making the connection more secure.

”When you put things inside a chain, the chain just gets longer—not stronger.”

We don’t need more protocols that no one talks to. We need better interoperability between the ones that already walk into the bar.

What’s your take? Are we over-engineering the “Chain of Trust” at the expense of actual implementation?

hashtag#Python hashtag#Broadcasting hashtag#SMPTE hashtag#ST2138 hashtag#MQTT hashtag#OSC hashtag#Networking hashtag#IPMedia hashtag#ST2110 hashtag#AES70

 

If you are in… …and you look at MQTT …and you look at OSC …and you look at AES70 …and you look at VISA/SCPI …and you look at ST-2138
MQTT — “A topic with a slash and no broker.” “A MIB with a pulse and strict rules.” “A slow, serial version of a topic tree.” “A topic wrapped in a locked box.”
OSC “A URL that needs a post office to deliver.” — “A rigid, humorless version of a path.” “My grandfather’s command set.” “A path that requires a passport to travel.”
AES70 “A messy, un-typed version of my objects.” “A flexible but dangerous lack of structure.” — “High-precision telemetry without the speed.” “The bouncer I have to hire to prove my worth.”
VISA/SCPI “A chaotic cloud of strings.” “A faster, UDP-based version of my tree.” “The professional upgrade I never got.” — “The security layer I never needed on a GPIB cable.”
ST-2138 “An insecure payload waiting for a signature.” “A naked path that needs a JWS wrapper.” “A trusted object that still needs a token.” “An ancient string that needs a modern ID.” —

 

 

The “All-to-All” Technical Breakdown

1. The Hierarchy (The Tree)

Whether it’s an MQTT Topic, an OSC Path, an AES70 Object, or a SCPI Command, they are all mathematically identical: A Directed Acyclic Graph (DAG).

  • Reality Check: Your Python implementation of ST-2138 is just navigating this same graph. When you “put things between the chain,” you aren’t changing the graph; you’re just adding a “checkpoint” at every node.

2. The Addressing (The ID)

  • MIDI uses hard-coded Channels/Notes (Physical/Layer 1-ish).

  • SNMP uses OIDs (Numerical/Tree).

  • AES70 uses Class IDs (Functional/Typed).

  • ST-2138 uses Cryptographic Keys (Identity/Provenance).

  • The Conflict: N-1 mapping fails here because we refuse to agree on who the device is. Is it “Device 01,” “IP 192.168.1.10,” or “Certificate Hash 0xAF32”? By adding ST-2138, we’ve added a fourth identity to a device that just wants to say “I’m on.”

3. The Telemetry Loop (The Heartbeat)

  • MQTT uses “Keep Alive” at the broker level.

  • AES70 uses “KeepAlive” at the TCP/Connection level.

  • OSC usually has no heartbeat (The “Silent Treatment”).

  • ST-2138 introduces “Heartbeat of Trust”—where the token must be refreshed.

  • The Reality: We have five different heartbeats running on the same wire. This is why the IPv6 packet is lonely; the network is so busy talking to itself about its own health and security that it has no bandwidth left for actual data.