
Network operations teams are being asked to trust AI agents with real production decisions. Building an agent that can summarize an incident or suggest a fix is one challenge. Letting that agent act inside a live network, with real customers and real service-level agreements on the line, is a different problem entirely. The gap is not model intelligence alone. It is governance, review, reproducibility, and the ability to roll back when an automated decision goes wrong.
Selector is trying to close that gap with a new technology called Foundry. Foundry is a development and runtime environment that lets network operations teams build, test, version, and govern their own AI agents inside the company's NetOps platform. The platform was updated earlier this year to provide a correlated view across branches, colocation facilities, on-premises data centers, and public cloud infrastructure. Foundry extends that foundation by treating an agent as a managed software artifact rather than an opaque automation script.
Why network AI agents need software discipline
Software engineering solved a similar trust problem over decades. Version control made changes traceable. Code review made changes inspectable. Staged rollouts limited blast radius. Rollback gave teams a recovery path. Continuous integration and deployment pipelines made promotion decisions repeatable. Selector is applying that same discipline to AI agents in network operations.
The company argues that the hard part is not telling a network team what is wrong. Its platform already correlates data and surfaces problems across hybrid infrastructure. The harder question is what to do next: what to fix, how to fix it, and how to prove the fix is safe before it is allowed to run. In many organizations, that work still depends on manual playbooks or custom scripts. Foundry is designed to move those decisions into governed agents that can be reviewed and replayed before production use.
How Selector Foundry works
Foundry treats an agent the same way a team would treat a piece of software, from framework choice through production rollout. That lifecycle includes framework selection, configuration, review, promotion, runtime guardrails, and autonomy management.
Pydantic AI and configuration as code
Foundry agents run on Pydantic AI. According to Nitin Kumar, co-founder and CEO of Selector, the company avoided heavier agent frameworks such as CrewAI in favor of something simpler and more deterministic. The design choice matters for network operations, where unpredictable behavior can create operational risk. Agents are defined as configuration, similar to infrastructure as code, and that configuration drives a common orchestrator with domain-specific code underneath it.
This approach gives network teams a repeatable way to describe what an agent should do. Instead of burying logic in one-off scripts, teams can express agent behavior as versioned configuration. The common orchestrator provides a consistent execution layer, while domain-specific code handles the details of network operations. The result is a structure that can be reviewed, tested, and promoted through environments.
Git-based review and one-step rollback
Customers commit agents to their own Git repository. Changes go through the customer's existing pull-request workflow. That means an agent update can be reviewed by the same engineers who review infrastructure changes, with the same approvals, comments, and audit trail. The repository remains under the customer's control, which is important for organizations that treat operational logic as intellectual property and compliance evidence.
Before an agent reaches production, it is replayed against the customer's historical incident data and compared against the recorded outcome of each past event. This incident replay acts as a promotion gate. If the agent's proposed actions or conclusions diverge from what actually happened, the team can see the mismatch before the agent touches a live network. A failed promotion rolls back in a single step.
Guardrails on cost and conclusions
Kumar described two kinds of limits on agent behavior. The first caps cost and token usage, limiting how many model calls an agent can make before it is treated as broken. That guardrail prevents runaway automation from consuming excessive inference budget or looping through unnecessary model calls. The second constrains what an agent is allowed to conclude. In one example, if an agent is reporting an AWS outage, it cannot blame GCP. That kind of constraint is intended to prevent hallucinated causal links that would send operations teams in the wrong direction.
The distinction is important. Cost guardrails protect the budget and runtime. Conclusion guardrails protect the integrity of the diagnosis. Together, they create a bounded environment where an agent can act with some autonomy while remaining accountable to known facts and approved reasoning paths.
Autonomy remains asymptotic
Kumar said full automation is the goal, but he does not expect that to be the immediate reality. The aim is to reach a state where things happen automatically, but he described the transition as asymptotic. In practice, network operations teams are likely to move through stages: agent-assisted diagnosis, agent-recommended remediation, agent-executed remediation with approval, and eventually broader autonomy for well-understood workflows.
That staged path mirrors how other high-stakes automation has matured. Teams do not hand over control all at once. They expand autonomy as confidence grows, as replay data accumulates, and as guardrails prove effective. Foundry is designed to support that progression rather than force an immediate leap to fully autonomous operations.
The workflows agents handle
Foundry agents are built around infrastructure support workflows. Handling one of these workflows today often means working through several sequential steps by hand, waiting for each one to finish, and then closing or opening a ticket depending on the outcome. Kumar described that work as manual until now.
If something happens, an operations team needs to check whether the underlying provider has maintenance going on. If it is not maintenance, the team needs to file a ticket for the provider. When a cloud outage hits, an agent first has to determine whether the problem is real. For example, it must establish whether a cloud provider such as AWS is actually down or whether the connection itself is fine.
The ability to troubleshoot an outage and determine what could be done is the most common workflow Selector expects. When an outage happens, an agent activates on its own and issues a plan of execution, followed by periodic status updates while the outage is ongoing. That workflow combines detection, diagnosis, provider coordination, and ticket management. It is a natural fit for an agent because it is repetitive, time-sensitive, and dependent on data from multiple systems.
Key facts at a glance
- Selector has introduced Foundry, a development and runtime environment for network operations AI agents.
- Foundry applies software engineering practices such as Git-based version control, pull-request review, staged promotion, and one-step rollback to agent development.
- Agents run on Pydantic AI. Selector chose a simpler, more deterministic framework over heavier options such as CrewAI.
- Agents are defined as configuration, similar to infrastructure as code, and run on a common orchestrator with domain-specific code underneath.
- Before production, agents are replayed against historical incident data and compared with recorded outcomes.
- Guardrails cap cost and token usage, and also constrain what an agent can conclude to prevent hallucinated causal claims.
- Selector expects full autonomy to be asymptotic, with automation expanding gradually rather than replacing humans immediately.
- Common workflows include cloud outage troubleshooting, provider maintenance checks, ticket filing, plan issuance, and status updates during incidents.
- Kumar said the next industry need is agent interoperability, including standards such as MCP and A2A.
- Selector is expanding into monitoring neoclouds and expects customer results within six months.
What comes next: interoperability and neoclouds
Kumar's answer for what comes next centers on agent interoperability. He said Selector will not be the only platform agents run on. The industry needs standard protocols, such as MCP and A2A, before agents built on different platforms can work with each other. Interoperability matters because network operations rarely live inside a single vendor's toolchain. An incident can span public cloud providers, private data centers, colocation facilities, network hardware, and observability platforms.
He also pointed to an expansion already underway into monitoring neoclouds. That buildout extends a cloud product Selector recently launched to compete with vendors such as Datadog. Kumar said existing data center monitoring tooling is not sufficient as that infrastructure gets built out. He expects to have customer results to share within six months.
Selector's main point of difference against established rivals, Kumar said, is that customers can build their own agents instead of working from a fixed set the vendor provides. The company called the product Foundry for a specific reason: customers can create things on their own because their data is theirs and their workflows are theirs. A vendor can only guess what those workflows are and what teams want to do. Kumar said the goal is not to curtail customer innovation or artificially bound what they want to do.
That philosophy places Foundry between a platform and a toolkit. It provides structure, governance, and runtime safety, but leaves the agent logic and repository ownership with the customer. For network operations teams under pressure to adopt AI without losing control, that balance may be the more relevant advance than any single model capability.
Source:Network World News
