If This, Then That Isn’t AI: From Traditional Automation to AI Orchestration

If This, Then That Isn’t AI: From Traditional Automation to AI Orchestration

If This, Then That Isn’t AI: From Traditional Automation to AI Orchestration

If This, Then That Isn’t AI: From Traditional Automation to AI Orchestration

If This, Then That Isn’t AI: From Traditional Automation to AI Orchestration

By Sam Kennedy

Part 2 of our series Troubleshooting with Lena


For years, one of the most powerful ideas in AV automation has been remarkably simple: if this happens, then do that. If a device goes offline, send an alert. If a room becomes occupied, turn on the display. If someone presses a button, route a source. If a system reports a particular error, perform a predefined action.


This type of automation has helped AV and UC environments scale tremendously. It works, and it's not going away.


But it has one fundamental limitation. Someone has to anticipate the trigger before they can program the response. As our environments become more interconnected and complex, that becomes increasingly difficult, because real-world problems don't always follow the scenarios we anticipated when we wrote the automation.


That's where the difference between traditional automation and AI orchestration starts to become important.


Traditional Automation Is Prescriptive

At its core, traditional automation requires us to define the relationship between a condition and an action: if this happens, then do this. That's incredibly powerful when we know the conditions we're looking for.


But someone has to build the logic, anticipate the scenario, decide what signals matter, and determine what action should occur. And as the number of devices and possible states increases, the number of potential scenarios grows right along with it.


Imagine a simple room with a display and a conferencing system. There are already multiple things that can go wrong. Now add a camera, microphones, a DSP, a control processor, switching, network infrastructure, USB devices, occupancy sensors, multiple displays, multiple sources, multiple conferencing platforms, and the integrations between all of them. Now add different manufacturers, firmware versions, configurations, room types, and use cases.


Every device doesn't exist independently. They're part of a system, and that's where troubleshooting becomes much more complicated than simply saying if device A reports X, perform action Y.


The Device Showing the Problem May Not Be the Problem

Here's an example we often demonstrate with Lena. A support ticket comes in and the user believes a particular device isn't working. That's what gets reported, so naturally that's where the administrator starts troubleshooting: they believe there is a problem with device A.


When Lena begins investigating she looks at the device, the environment, and the devices connected to it, and through that process she may determine something important: device A isn't actually the problem. The problem is device B. Device A is simply where the symptom appeared.


That's a very normal troubleshooting scenario for an experienced technician. The display isn't showing content. Does that mean the display is broken? Maybe. Or maybe the source isn't sending a signal. Maybe something upstream isn't configured correctly. Maybe another device in the signal path isn't behaving as expected.


The user sees the symptom at the display. An experienced AV professional understands that the root cause could be somewhere else entirely. That distinction matters when we talk about automation.


What Rule Would You Have Written?

Think about how you would automate that scenario traditionally. You'd need to anticipate the failure, know which signal indicated the problem, and understand the relationship between the devices. Then you'd need to write logic that says if A exhibits this condition, check B.


But what if the problem is C? Then we need another rule. What if A and B are functioning correctly, but D is misconfigured? Another rule. What if the symptom changes depending on the room configuration? Another rule. What if a firmware update changes the behavior? Another rule. What if the same symptom has five possible causes? Now we need a decision tree.


This can be done. We've been doing it for years. The problem is that someone has to imagine, build, test, and maintain those paths, and the real world has a habit of creating scenarios nobody thought to put into the script.


You Can't Hard-Code the Real World

This is the fundamental scaling challenge. The more interconnected the environment becomes, the more possible combinations of conditions exist. You have devices talking to devices, software talking to hardware, cloud platforms interacting with local systems, configurations changing, users changing things, firmware changing, networks changing, and room use changing throughout the day.


The number of possible failure scenarios becomes enormous. Traditional automation asks us to anticipate those scenarios. AI gives us another option. What if we don't have to program every troubleshooting path in advance? Instead of defining every if-then relationship, we can give AI access to the appropriate context, tools, and systems and allow it to reason through what is happening. That's a very different model.


Automation Executes a Path. AI Can Find the Path.

This is the distinction I think matters most. Traditional automation is excellent at executing a predefined workflow: if we know X happened, do Y.


AI orchestration can start with something much less precise, like “this room isn't working.” Now the system has to determine what to investigate. What's in the room? What is the current state, and what should the state be? Which devices are involved, and what relationships exist between them? Where are the symptoms appearing, and could the root cause be somewhere else? What can be tested, what actions are available, and what happened after an action was taken?


Instead of simply following a path someone created beforehand, AI can help find the troubleshooting path based on the situation it encounters. That's a significant change.


That's Why Natural Language Matters

In Part 1 of this series, we started with one of the least useful support tickets imaginable: the conference room isn't working. Traditional automation doesn't have much to work with there. Which condition should trigger? Which workflow should run? Which device is broken? The request isn't prescriptive enough.


But that's exactly how humans communicate. Users describe symptoms, make assumptions, leave out information, and blame the device they can see. They don't know the topology of the room, and they shouldn't have to.


With Lena, the administrator can begin with that ambiguity, whether it's “the conference room isn't working” or “the user says there's a problem with the display.” That becomes the beginning of the troubleshooting process rather than a requirement for the human to diagnose the problem before the automation can help. The AI can begin investigating.


AI Orchestration Is About More Than Generating an Answer

This is also where I think the word orchestration matters. The objective isn't for AI to produce a paragraph suggesting five things an administrator could try. That's helpful, but it isn't the end goal.


Lena can work across the environment. She can gather information, inspect devices, understand relationships, test assumptions, help determine a root cause, and, when appropriate, take an action, then evaluate what happened next.


The interaction starts looking less like question and answer, and more like understand, investigate, reason, act, and verify. That's an operational workflow.


Think Like a Technician, Not a Script

An experienced technician doesn't walk into a room carrying a giant list of every possible failure that could ever occur. They troubleshoot. They start with the symptom, gather information, form a hypothesis, and test it, and what they learn determines what they investigate next.


Maybe the user says the display is broken. The technician discovers the display is functioning, so they move upstream, check the connected device, then the next component, and eventually find the actual problem. The troubleshooting path evolves based on what they learn.


That's much closer to what we're trying to enable with AI orchestration. The next step can be determined by the result of the previous step. We don't necessarily have to know the entire path before the troubleshooting process begins.


The Difference Is Scale

This is why I don't see AI orchestration as simply a smarter version of traditional automation. Traditional automation helped AV scale by allowing us to automate known, repetitive actions, and it will continue to be incredibly valuable for exactly that.


But AI has the potential to help us scale something that has historically been much harder to scale: troubleshooting knowledge. An experienced AV engineer might have spent years learning that the device showing the symptom isn't necessarily the device causing the problem. They've developed intuition, they know where to look next, and they understand how systems interact. That knowledge is extremely valuable. It's also scarce.


If AI can help perform some of that investigation, a generalized IT administrator can potentially resolve issues that previously would have required escalation to an AV specialist. Now the expert doesn't need to touch every ticket. Their expertise can be reserved for the genuinely difficult problems. That's not just automation. That's a different way of scaling the operation.


It Also Changes What We Have to Predict

There is another operational benefit that's easy to overlook. With traditional automation, somebody has to maintain the automation itself. A new scenario means creating a rule. A new device potentially means updating the logic. A new failure mode means building another workflow. A new combination nobody anticipated means someone has to figure it out and encode it.


That means we're not just maintaining the AV environment. We're maintaining our assumptions about everything that could happen inside it.


AI orchestration reduces our dependence on anticipating every scenario in advance. That doesn't mean there are no guardrails, and it doesn't mean AI should be allowed to do anything it wants, or that deterministic automation disappears. It means we can separate two different problems: where the condition and desired action are known, automate it, and where the situation requires investigation and reasoning, orchestrate it. That's a much more powerful combination.


Deterministic Where It Should Be. Intelligent Where It Needs to Be.

This is important because I'm not arguing that every automation should suddenly become AI. If someone walks into a room and you want the lights to turn on, you probably don't need artificial intelligence debating what to do. Occupancy detected, lights on. Keep it simple. Predictable actions benefit from predictable automation.


But troubleshooting is different. Troubleshooting begins with uncertainty. Something isn't working, and we may not know what or why. The symptom may be coming from somewhere other than the root cause, and the user may even be wrong about what's broken. That's exactly where reasoning becomes valuable.


So perhaps the future isn't traditional automation or AI. It's traditional automation and AI orchestration. Use deterministic logic for the things we know, and use AI to navigate the things we don't.


From Programming Every Scenario to Defining the Outcome

This may ultimately be the biggest change. For years, building sophisticated AV automation meant anticipating scenarios: if this happens, do this, if that happens, do that, if this device reports this state while another device reports another state, follow this workflow.


That approach has taken our industry a long way. But there will always be another scenario, another combination, another unexpected failure, another user who tells us the display is broken when the real problem is three devices upstream. We shouldn't have to predict every one of them.


The opportunity with AI orchestration is to start with the outcome: find out why the room isn't working. Give the AI the context and tools it needs, let it investigate, and let what it discovers inform what it does next. Bring the human in when human judgment or physical intervention is required.


Traditional automation requires us to program the path. AI orchestration allows us to define the destination and reason through the path along the way. In environments with thousands of interconnected devices and an almost limitless number of ways something can go wrong, that difference matters. A lot.



To learn more or to schedule a demo:
Visit: www.netspeek.ai
Contact: lena@netspeek.com

Subscribe for Updates

Stay current with the latest from NetSpeek. Learn more about new capabilities, product announcements, technical insights, and thought leadership in AI for AV.

Copyright © 2026 NetSpeek Inc. 313 Washington St. Newton MA 02458. All Rights Reserved.

Copyright © 2026 NetSpeek Inc. 313 Washington St. Newton MA 02458.
All Rights Reserved.

Copyright © 2026 NetSpeek Inc.
313 Washington St. Newton MA 02458.
All Rights Reserved.