Building an Autonomous Data Science Agent for Telecom Migration Eligibility with the NVIDIA Agent Toolkit
Telecommunications carriers modernizing their business-support systems face a deceptively hard problem before a single customer is migrated : they have to assess every customer record for migration readiness and sequence thousands of accounts into delivery waves. Done manually or with brittle rule sets, this process is slow, error-prone, and blind to the probabilistic signals that actually predict a successful cutover.
We built an autonomous data science agent to solve this, with the NVIDIA Agent Toolkit. The agent takes a plain-English business question, runs the complete machine-learning lifecycle without human intervention, and returns a scored, calibrated, interpretable result an architect can act on. This post explains how we built it, why each NVIDIA component was essential, and what the system produced on a synthetic dataset modeled on real migration patterns.
The Problem: Migration Eligibility at Scale
A Telco migrating its estate to a cloud-native business-support system (BSS) must assess every account across dozens of attributes, including tenure, plan type, billing posture, and eligibility signals, before committing to a plan. A binary pass/fail checklist cannot rank accounts by likelihood of success, surface the feature drivers behind a prediction, or quantify the uncertainty a delivery team needs to sequence work safely.
What this problem calls for is a trained classification model: one that discriminates eligible from ineligible accounts, produces calibrated probabilities rather than flat verdicts, and explains its predictions in terms a non-specialist can act on. The challenge is getting from a business question to a deployable model without the weeks of exploratory iteration a traditional data science workflow requires.
That gap is what the agent closes.
What the Agent Does
The agent accepts a goal in natural language and takes over. It moves through four stages, including business understanding, exploratory analysis, feature engineering, and modeling, composing and executing Python at each step, reading outputs, and deciding what to do next.
When code fails on data it has never seen, the agent reads the traceback, rewrites the code, and retries. Nothing is a pre-recorded pipeline. The work is assembled live, from the goal.
Key behaviors:
- Adaptive execution. The agent runs only the stages a question requires. A purely exploratory ask stops after analysis rather than forcing a full modeling run. An orchestrator agent derives the path from the goal rather than following a fixed script.
- Self-correcting code generation. Errors route directly back into a fresh code-generation attempt with the traceback in context. No human is needed to unstick a failed step.
- Decision-ready output. The final artifact is a scored, ranked account view with calibrated probabilities and the feature importances behind them, not just a model file.
Architecture: A Layered Multi-Agent System
The design separates concerns cleanly across three layers.
The Orchestrator
The orchestrator agent sits at the top. It holds four specialist sub-agents as callable skills, covering business understanding, exploratory analysis, feature engineering, and modeling, and owns all judgment about which to invoke, in what order, and what context to pass between them. The orchestrator uses deep planning: it reasons about the full task before calling the first sub-agent.
Three specialist subagents handle analytical work. Rather than maintaining three separate implementations, we built one generic plan-and-execute engine and parameterized it per stage. That engine follows a consistent loop: an LLM drafts a step plan and marks which steps can run in parallel, a deterministic executor walks the plan, LLM code generation handles each step, failures recycle back into code generation with error in context, and a synthesis step folds all outputs into a structured report for the next stage.
Business Understanding Subagent
The business understanding subagent follows a distinct ReAct pattern with tools rather than the shared engine. Its job is structured problem framing, not code execution.
The entire system runs inside the NVIDIA OpenShell secure runtime, which includes individual agent sandboxes and policy enforcement tools. The operator interface on the host communicates with the in-sandbox backend over a controlled channel, so every data file, execution, and artifact stays behind the sandbox boundary.
The NVIDIA Stack: Why Each Component Matters
An autonomous agent that writes and executes its own code is only as trustworthy, and as fast, as the platform beneath it. Four NVIDIA components accelerate and power this system.
NVIDIA OpenShell: Safer Code Execution by Construction
The agent generates and runs arbitrary Python. Containment is not optional.
OpenShell enforces isolation out-of-process: egress is locked to the endpoints the agent legitimately needs, file access is scoped to defined directories, and every execution is audit-logged. Because isolation is enforced at the infrastructure level, neither a prompt injection nor an unexpected dependency install can break out of the runtime. This containment is what allowed us to give the agent genuine autonomy, writing and running code without a human approval step, while keeping the system safe to operate.
NVIDIA NeMo Agent Toolkit: Composability Without Hardwiring
The NeMo Agent Toolkit gave us a configurable foundation rather than a hardwired one. It wraps the underlying graph so the moving parts, including which model serves which role, how many steps run in parallel, and how retries behave, are expressed as configuration, not bespoke code.
The same workflow definition runs as a one-shot job, as the HTTP service the operator interface calls, and as an evaluation harness, with nothing rewritten between modes. Framework-agnostic by design, the toolkit also makes it straightforward to swap or extend components as the system evolves.
NVIDIA NIM with Nemotron and Qwen Coder: Right Model, Right Role
Not all reasoning tasks in an agentic system are the same. The orchestrator needs to produce well-formed structured output, including tool calls, stage plans, and context handoffs, where correctness of format is critical. The code-generation steps need a model that understands APIs, DataFrames, and ML patterns at depth.
We served both roles through NIM, using Nemotron 3 Super for orchestration and planning, and a Qwen Coder model for code generation. NIM handled deployment for both without requiring separate infrastructure for each, and matching each model to its role improved reliability across the board.
CUDA-X for Data Science: Pandas and Scikit-learn on GPUs
The agent's pandas and scikit-learn steps use zero code change accelerators in NVIDIA libraries cuDF and cuML, running exploration, feature engineering, and model training onto GPU hardware with no code changes. For a single account book the benefit is faster iteration; across a full population it is the difference between an overnight batch job and interactive exploration. Running on GPU, the agent can train and compare more candidate model configurations in the same wall-clock budget, which directly improves the model it ships.
Arize Phoenix: Observability for Autonomous Decision-Making
A system making autonomous decisions needs to be observable, not just functional. A single telemetry block activates full tracing: every LLM call, code execution, and specialist invocation produces a span in a complete tree showing latency and token usage at every level. For an agent operating without human checkpoints, that visibility is the difference between trusting the system and guessing at what it did.
Results: What the Agent Produced
Running on this stack, the agent autonomously completed the scenario end-to-end from a single plain-English goal
- It owned the full data science lifecycle. From the initial prompt, the agent framed the classification problem, profiled the data, engineered features from raw account attributes, and trained and compared multiple candidate classifiers, including logistic regression, random forest, and gradient boosting, selecting the strongest performer on held-out data.
- The model is decision-ready, not just accurate. The trained classifier discriminates eligible from ineligible accounts with strong separation and well-calibrated probabilities, giving delivery architects a ranked account queue with a confidence score on every record rather than a flat pass/fail list.
- The agent interrogated its own model. From the trained model's feature importances, the agent surfaced, without being asked, that a single eligibility condition was the dominant predictor of ineligibility, responsible by a wide margin for the largest share of blocked accounts in the population.
- It translated the finding into a concrete recommendation. In plain language: resolve that one condition and you unblock the largest cohort of customers in a single operational move. That is the highest-leverage input to a wave plan, reached autonomously on a dataset the agent had never seen, in a single pass.
What Comes Next
This architecture establishes the core loop: one business question in, a complete and traceable data science artifact out. The path to production is concrete:
- Full-population scale on RAPIDS, where GPU acceleration moves training from overnight to interactive for the complete account book.
- Continuous evaluation so model quality is measured automatically on every data or model change.
- Validation and drift monitoring for a live scoring environment where account attributes evolve between planning and execution.
Autonomous execution is handled by the agent. The speed, safety, observability, and scale is ensured by the stack. Built with NVIDIA Agent Toolkit, an agent that writes and runs its own code stops being a compelling demonstration and becomes something an enterprise can put directly to work.
The scenario described in this post runs on a synthetic dataset modeled on real BSS migration patterns. No production operator data was used. To learn more about NVIDIA NeMo Agent Toolkit, NVIDIA NIM, and RAPIDS, visit developer.nvidia.com.
