Case study

Event-driven network automation with AI-assisted troubleshooting

Network service provider

Service Providers →

The operator wanted network operations driven by events, not by people copying signals between screens and opening tickets. We built an event-driven, Kubernetes-native automation platform scaled by KEDA and fed by real signals. Splunk searches surface operational events. New-service bookings originate in Salesforce and flow into provisioning. On top of it we built an LLM-assisted troubleshooting layer that uses LangChain Deep Agents arranged around a blackboard pattern, with human-in-the-loop checkpoints. It triggers automated testing at the affected site the moment a performance or provisioning issue shows up.

Event-driven
automation, not ticket-driven
KEDA-scaled
Kubernetes-native workers
LLM-assisted
troubleshooting, human-in-the-loop

The challenge

The operator ran its network the way most still do. People watched dashboards and opened tickets, then worked the same troubleshooting steps every time the same class of problem came back. It worked, but it didn’t scale. Every new service and every performance blip fell to the same finite team, and the gap between something going wrong and someone noticing stretched across dashboards refreshed and tickets triaged. What they wanted was an operation driven by events, where the network responds to what is actually happening to it rather than waiting for a human to notice and react.

For a service provider, that gap is more than a workload problem. It hits revenue and reputation. Every minute a service stays degraded is a minute a customer feels it, and a team that can only scale by hiring hits a ceiling fast. They needed the network to carry more of its own weight.

What we did

We built an event-driven automation platform, Kubernetes-native from the start. KEDA scales the automation workers on demand in response to real events, so the system does work the moment there is work to do and costs next to nothing when there isn’t.

Then we connected it to the events that actually matter. Splunk searches surface operational signals from across the network. New-service bookings that originate in Salesforce arrive as messages on an Amazon SQS queue and flow straight into provisioning, so a sale becomes a provisioning action without anyone rekeying a thing. The network started to respond to what was happening to it, in something close to real time.

On top of that we built the part the operator was most excited about: LLM-assisted troubleshooting. Using LangChain Deep Agents arranged around a blackboard pattern, the system reasons over incoming signals and shares findings across specialized agents working the same problem, driving toward a diagnosis. It keeps a human in the loop at the decisions that warrant one, so the automation earns trust rather than fear. And the moment a performance issue or a provisioning challenge shows up, the platform triggers automated testing at the affected site, turning detection immediately into diagnosis instead of a ticket in a queue.

Why it mattered

Beyond automation for its own sake, the payoff is concrete. Provisioning that starts from a booking means new revenue turns on without waiting in a human queue. Troubleshooting that starts the moment a problem appears means issues get caught while they are still small. And the team’s scarce expertise goes into supervising an intelligent system and handling the hardest cases, rather than repeating the same first ten steps on every ticket. The operation scales with the network now, not with headcount.

The range it took

This is the kind of system that only works when one team is comfortable with Kubernetes internals and an operator’s Splunk and Salesforce data, and equally at home designing an agentic AI system a NOC will actually trust in production. We architected the event-driven core and engineered the integrations. We designed the human-in-the-loop agent layer and tuned it against the messy reality of a live network. Working across infrastructure, data, and AI at once is what let the pieces add up to something an operator could put its name on.

What we built

An event-driven core, the signals that drive it, and an AI layer a NOC can actually trust.

We led this

Event-driven automation core

A Kubernetes-native automation core that scales its workers on demand with KEDA, doing work the instant there is an event to act on and costing nothing when the network is quiet.

We built this

Signal sources: Splunk & Salesforce

Wired in the events that matter. Splunk searches surface operational signals from across the network, and new-service bookings that originate in Salesforce arrive as Amazon SQS messages that flow straight into provisioning.

We built this

LLM-assisted troubleshooting

An agentic troubleshooting layer built on LangChain Deep Agents around a blackboard pattern, reasoning over the incoming signals and sharing findings across specialized agents, with human-in-the-loop checkpoints wherever a decision warrants one.

We built this

Automated on-site testing

The moment a performance issue or a provisioning challenge is observed, the platform triggers automated testing at the affected site, so detection turns straight into diagnosis instead of a queued ticket.

The outcome

The operator moved from a network run by people watching screens to one that responds to its own events. Provisioning starts from a booking. Troubleshooting starts the moment a problem appears, and the team's expertise now goes into supervising an intelligent system rather than repeating the same manual steps.

Have a program like this ahead of you?

This is the kind of work we're built for. Tell us where you're starting from.