Autonomy by Design
It was an evening I did not expect to turn philosophical.
My kid and I had just wrapped up a coding class for children, one of those weekend sessions where you watch young minds light up as they discover they can tell a machine what to do. A retired military officer was there with his grandchildren. We got to talking, the way you do after you have watched kids debug their first loop together. The conversation drifted, as conversations do, from the kids to technology, from technology to AI, from AI to autonomous cars.
Then he stopped me with a question I was not ready for.
Say the car loses its brakes. It can’t stop. There is no third option. No open road, no escape route, no way to avoid what is coming. Just two paths. On one side is a farmers market, a lot of people, families, kids shopping. On the other side, a few people waiting for a bus. The car must go one way or the other. What does the autonomous system do?
I kept thinking about what a human driver would do in that moment. They would scream. They would lean on the horn. They would wave frantically out the window. They would swerve, pull the handbrake, do ten panicked things at once (none of them optimal), all of them human. They would improvise in ways no algorithm anticipated because humans carry something machines do not: the ability to act outside the boundaries of what they were taught.
The autonomous car cannot scream. It can only do what it was programmed to do.
I did not have a good answer that evening. But I have been thinking about it ever since because the same question, stripped of its drama, sits at the center of everything we are building in network infrastructure today.
The Question Behind the Question
The veteran was not really asking about brakes. He was asking: who programs the ethics? When a system is trusted to make consequential decisions on its own, who decided what the right decision looks like? Who defined the tradeoffs? And what happens when the situation falls outside the boundaries of what was anticipated?
Every day, the networks underpinning AI infrastructure face versions of that same dilemma. Not with lives at stake, but with workloads that matter enormously to the organizations depending on them. A training job consuming thousands of GPUs. A real-time inference pipeline serving millions of users. A congestion event that, handled badly, cascades into hours of degraded throughput. The network must make decisions fast, accurate, and often without a human in the loop, about where the traffic flows, which flows get priority, and when to intervene.
AI is coming into the network either way. The question is what kind, at which layer, and who decides what it’s allowed to do. And whether we build it with the same care the veteran’s question deserves.
Telemetry Is the Foundation of Everything
You cannot fix what you cannot see. You cannot predict what you have never measured. And you cannot build real self-operations or autonomy on top of a blind fabric.
This is where the conversation has to start: telemetry. Not metrics collected once a minute and shipped to a dashboard someone checks in the morning. Real telemetry: streaming and fine-grained, capturing the actual behavior of the network as it happens. How much data is waiting to move. How heavily each path is loaded. Where traffic is building up and where it is flowing freely. The fabric’s heartbeat, in continuous motion.
At Aria, telemetry is not a feature. It is the core of the architecture, and the foundation of what we call Deep Networking: intelligence built into every layer of the network, from the switch to the host, rather than bolted on afterward. Without it, every other capability (closed-loop remediation, intent deviation detection, predictive congestion management, etc.) is operating in the dark. A model can only reason about what it can see.
The AI workloads running on top of these fabrics are unforgiving. A 400-node training job is effectively one distributed application. When the network hiccups from unexpected congestion, when congestion-control settings are not tuned for the workload in flight, when one part of the fabric starts to back up and the pressure ripples outward, the entire job feels it. GPU utilization drops. The collective communication stalls. What should have been a throughput-optimized run becomes an exercise in waiting for the network to recover.
The network needs to know this is happening before the application does. That requires telemetry at the speed of the problem.
Human Judgment at Machine Speed
Autonomy is not the absence of human judgment. It is the operationalization of human judgment, the encoding of intent, goals, constraints, and tradeoffs into a system that can act on them faster and more consistently than any human operator could.
This distinction matters. The autonomous car in the veteran’s scenario is not making a moral decision. It is executing the moral decisions that were made when it was designed. The ethics were baked in at build time. The car is just running the code.
The network works the same way. When we talk about closed-loop remediation at Aria, we are building a system that can continuously compare the network’s actual behavior against an objective or goal, and act when necessary. That goal is defined by humans. The thresholds, the priorities, the acceptable ranges for latency and loss and queue depth, all of it is authored by people who understand the workloads and the infrastructure.
What the system does is watch, compare, decide, and act. At machine speed, without waiting for a ticket to be filed or a dashboard to be checked.
When a flow deviates from its expected pattern, the system notices. When congestion is building in a way that historical telemetry suggests will cascade, the system acts before the cascade begins. When early signals in the network indicate that pressure is approaching a point of no return, the system intervenes. Rerouting, rebalancing, adjusting, before the application ever sees the impact.
This is not magic. It is measurement, pattern recognition, and pre-authorized action. The autonomy is in the speed of execution. The judgment is still human.
Not every decision happens at the same speed, so they don’t all live in the same place. On the switch, narrow, specialized models react in microseconds, inside limits people set ahead of time. Across the fabric, control loops rebalance within approved ranges. At the top, AI does what a senior engineer would do by hand: investigates, explains what it found, and hands a person a plan.
Closed-loop remediation at Aria works inside a fixed menu of pre-authorized actions, each one scoped in advance by the people who defined the intended goals. Within that menu, the system moves fast. It reroutes a flow, rebalances load across paths, and adjusts queue and scheduling parameters within ranges someone has already approved, often before an operator would have seen the alert. For the people running the fabric, that means faster recovery and fewer pages at 3 a.m. The same design sets the limits. The system does not reason toward a goal, and it cannot rewrite policy, push a new configuration, or take an action whose consequences reach beyond what was scoped for it. That boundary is not a limitation we are working around. It is the design.
Designed Together
Autonomy at this level cannot be bolted onto a network from the outside. It works when the hardware and software are co-designed. We build the switches and the software that runs them, so the telemetry layer sees every buffer, queue, and counter as it changes, and the actions the system is allowed to take are scoped to what that hardware can actually do.
Our operating system, AriaOS, is built from a SONiC foundation, which keeps that design open. Its interfaces let the telemetry, the agents, and the switch itself work as one system instead of multiple vendors’ best guesses about each other. It also keeps the boundary honest. Our customers can see in Aria Console exactly which actions the system may take, and check what it did and why, rather than trusting a black box at the most critical layer of their AI infrastructure.
Back to the Original Question
When I think about where this is heading, I keep coming back to that evening and the veteran’s question.
The answer to “what will the autonomous system do?” is always the same: it will do what it was taught to do. No more, no less. The system is a direct reflection of the thinking that went into building it. It shows in the clarity of the intent, the depth of the telemetry, and the precision of the tradeoffs encoded into the remediation logic.
At build time, we set the standard: an AI network designed, instrumented, and operated end to end. Designed so the fast decisions happen on the switch, where the traffic is. Instrumented so it can tell the difference between up and healthy. Operated by agents that take people out of the toil and keep them in the decisions.
The kids in that coding class are going to build the systems that run the world. The veteran’s question “Who decides what the machine does when things go wrong?” is the most important question they will ever have to answer.
Your network is already giving you warnings. Most tools can’t hear them. Book a demo and we’ll show you what yours is saying, what our agents would handle on their own, and what they’d hand to you.
