New opportunity

Data scientist - Agentic AI

HPE · San Jose, United States of America

About this role

HPE seeks a Data scientist - Agentic AI to build and operate agentic workflows for Marvis, Juniper’s AI assistant for network operations. The role develops reasoning pipelines, tool integrations and production systems that help diagnose, troubleshoot and resolve networking problems. It is primarily based at an HPE office in San Jose, California, and is a 40-hour-per-week, full-time position.

Responsibilities

  • Design LangGraph workflows using ReACT loops, dynamic tool selection, multi-step reasoning and self-correction. Develop MCP servers, domain-specific tools, schemas and skill playbooks, and manage their deployment and monitoring.
  • Integrate production-scale LLM capabilities, including structured outputs, streaming, function calling, prompt engineering and error handling. Build RAG, semantic and hybrid retrieval, and long-term agent memory services.
  • Define metrics and test harnesses, run A/B tests, and improve the quality of non-deterministic workflows. Collaborate with network engineers and product managers to turn troubleshooting procedures into skills, tools and data pipelines.
  • Develop data analysis and transformation logic for sandboxed execution. Deploy containerized services on Kubernetes and maintain CI/CD, tracing, logging, cost tracking and performance monitoring. The role may include team leadership and mentoring.

Required qualifications

  • Master’s or PhD in computer science, data science, mathematics, statistics or a closely related quantitative field. Typically 4–6 years building production ML/AI systems, including at least 1–2 years of hands-on generative AI and LLM application work.
  • Production experience with an agentic framework, understanding of agent design patterns and MCP or comparable tool-serving protocols; experience with LLM APIs, RAG and evaluation of non-deterministic AI systems.
  • Statistical and machine-learning foundations, production Python development, Kubernetes, CI/CD, Docker and container registries, backend API development, and AI-system observability.

Preferred qualifications

LangGraph is strongly preferred among agentic frameworks. Experience with agent memory, sandboxed code execution, AWS Bedrock or OpenSearch Serverless is preferred. Networking diagnostics knowledge is a plus, not a requirement; strong written and verbal communication is also preferred.

California base salary is USD 155,500–315,000 annually; offers vary by location, experience, education and skills, and variable incentives may be offered. HPE describes health and wellbeing benefits and career-development programs.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

Agentic AIGenerative AILarge Language ModelsLangGraphLangChainClaude Agent SDKReACTModel Context ProtocolTool callingPrompt engineeringRAGSemantic searchHybrid searchVector storesOpenSearchAgent memoryAI evaluationA/B testingLLM-as-judgeMachine learningAnomaly detectionTime-series analysisClusteringCausal inferencePythonKubernetesCI/CDJenkinsGitHub ActionsArgoCD GitOps Platform (Argo CD) (ArgoCD) - tool for Kubernetes continuous deliv

Your skill match

Checking your profile…

YOUR NEXT STEP

Get interview-ready for this role

A focused preparation guide, built around this job’s responsibilities and requirements.

✦ AI-generated guide
Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.
01

Understand the role

What matters most

  • Build Marvis agent workflows

    Role: Design and iterate on LangGraph workflows for network diagnosis and troubleshooting, including ReACT loops, dynamic tool selection, multi-step reasoning, and self-correction. Preparation: Be ready to explain production design decisions and failure handling, not just a prototype.

  • Turn procedures into reliable tools

    Role: Work with network engineers and product managers to translate troubleshooting playbooks into skills, domain-specific tools, and data pipelines; develop MCP servers, tool schemas, and skill playbooks. Preparation: Outline how you would make a procedure precise enough for an agent to execute and maintain.

  • Ground and integrate LLM behavior

    Role: Integrate structured outputs, streaming, and tool calling at scale while building RAG, hybrid retrieval, relevance tuning, and agent memory services. Preparation: Explain when retrieval, memory, or a more constrained output format would be appropriate.

  • Measure agent quality

    Role: Define metrics and test harnesses, run A/B tests on skills and tool configurations, and improve non-deterministic workflows. Preparation: Describe how you would compare versions using representative troubleshooting cases and inspect failures.

  • Operate observable production services

    Role: Deploy containerized services on Kubernetes and contribute to CI/CD, health probes, and resource optimization; own tracing, logging, cost tracking, and performance monitoring. The role also includes sandboxed data-analysis logic. Preparation: Connect implementation choices to operational reliability.

Likely challenges to think through

  • Autonomy versus controlled execution

    Likely challenge, not a confirmed issue: Dynamic tool selection and self-correction could help resolve complex cases but also create unnecessary or erroneous execution paths. Prepare to discuss tool-schema validation, bounded execution, error handling, and trace-based debugging.

  • Quality signals for variable outcomes

    Likely challenge, not a confirmed issue: Non-deterministic agents may produce different paths for the same problem, making a single pass/fail measure insufficient. Prepare a plan for case-based tests, outcome and intermediate-step metrics, and A/B comparisons of skills or tool configurations.

  • Useful context versus stale or irrelevant context

    Likely challenge, not a confirmed issue: RAG and long-term memory can add diagnostic context while also retrieving irrelevant or outdated material. Prepare to explain relevance tuning, re-ranking, and how you would evaluate whether stored context improves troubleshooting.

  • Capability versus production cost and latency

    Likely challenge, not a confirmed issue: Multi-step LLM calls and tool use can improve reasoning while increasing execution time and cost. Prepare to discuss how traces, cost tracking, performance monitoring, and resource optimization would inform those trade-offs.

03

Practice your answers

Technical practice

How would you design a LangGraph workflow to troubleshoot a network problem using ReACT, dynamic tool selection, and self-correction?

What to coverThe posting calls for these agentic patterns in Marvis workflows. Suggested preparation: explain how you would represent state, select and validate tool calls, limit loops, and decide when the agent has enough evidence to respond.

How would you design and operate an MCP server that exposes domain-specific troubleshooting tools?

What to coverThe role includes tool schemas, skill playbooks, registry management, and server versioning, deployment, and monitoring. Suggested preparation: discuss schema clarity, error contracts, compatibility across versions, and how a playbook would guide tool use.

How would you make LLM API calls reliable in a production agent?

What to coverThe posting specifies structured outputs, streaming, function calling, prompt engineering, error handling, and cost optimization. Suggested preparation: compare validation and retry approaches for malformed outputs or failed calls, including their effects on latency and cost.

How would you tune retrieval for a troubleshooting RAG pipeline?

What to coverThe role covers chunking, vector-store search, hybrid retrieval, re-ranking, and relevance optimization. Suggested preparation: explain how you would compare retrieval configurations using representative troubleshooting queries and inspect failures where relevant evidence is missed.

When should an agent use long-term memory, and how would you evaluate whether it helps?

What to coverThe posting names semantic, episodic, and procedural memory as areas of work. Suggested preparation: distinguish what each could retain, then discuss relevance, stale information, and a comparison against an agent without memory.

How would you evaluate changes to a non-deterministic agentic workflow?

What to coverThe role calls for metrics, test harnesses, offline evaluations, A/B tests, and evaluation of skill and tool configurations. Suggested preparation: describe how you would measure troubleshooting quality alongside tool errors, latency, and cost, while accounting for variation between runs and limitations of LLM-as-judge.

How would you choose a statistical or ML method to investigate an apparent network anomaly?

What to coverThe posting requires foundations in anomaly detection, time-series analysis, clustering, causal inference, or related methods; networking expertise is a plus, not a requirement. Suggested preparation: explain what data and baseline you would need, how you would check false positives, and why an observed association would not by itself establish a cause.

How would you run agent-generated analysis and transformation logic in a sandbox?

What to coverThe role includes sandboxed execution for multi-tool scripts, aggregation, and visualization. Suggested preparation: discuss limits on execution and data access, validation of inputs and outputs, and how failures would be reported back to the workflow.

How would you ship a Python-backed agent service to Kubernetes?

What to coverThe posting specifies production Python, backend APIs, container images, CI/CD, Kubernetes workloads, health probes, and resource optimization. Suggested preparation: walk through an API boundary, automated tests and image versioning, then explain how probes and resource settings support a safe deployment.

How would you diagnose a production agent that has become slower, costlier, and less accurate?

What to coverThe role assigns ownership of tracing, logging, cost tracking, and performance monitoring for agentic workflows. Suggested preparation: show how you would inspect traces across reasoning steps, retrieval, and tool calls, isolate a regression, and verify a fix against quality as well as operational metrics.

Behavioural practice

Tell me about a time you translated a domain expert’s procedure into a technical workflow.

What to coverThe posting calls for collaboration with network engineers and product managers to turn troubleshooting playbooks into skills, tools, and data pipelines. Suggested preparation: use a real situation, your actions to resolve ambiguities with experts, and the result, without assuming networking experience is required.

Describe a time you chose an approach independently under technical uncertainty.

What to coverThe role calls for significant independent judgment on complex technical problems. Suggested preparation: give the situation, the alternatives and evidence behind your action, and the result or what you learned.

Tell me about a time you investigated a production AI or software reliability problem.

What to coverThe posting emphasizes reliable, observable production systems and troubleshooting failures. Suggested preparation: describe the situation, your diagnostic and communication actions, and the result, including how you checked that the issue was resolved.

Describe a time you helped another engineer improve their work.

What to coverThe role may include team leadership and mentoring. Suggested preparation: use a real situation, explain the specific guidance or feedback you gave, and state the resulting change without claiming formal management responsibility.

Tell me about a time you explained a complex technical trade-off to decision-makers.

What to coverThe posting prefers the ability to articulate technical designs to senior leadership. Suggested preparation: identify the audience and decision, describe how you presented alternatives and uncertainty, and explain the resulting decision or feedback.

02

Sharpen your knowledge

Topics to prepare

  • Agent orchestration patterns

    Posting: The role calls for ReACT loops, dynamic tool selection, multi-step reasoning and self-correction. Revision exercise (suggestion): Draw a troubleshooting workflow and explain when it should call a tool, retry, correct an error or stop.

  • MCP tool contracts and lifecycle

    Posting: MCP or a comparable tool-serving protocol is required; responsibilities include schemas, registry management, versioning and monitoring. Revision exercise (suggestion): Review a sample tool schema for ambiguous inputs and outputs, then describe how a compatible change would be deployed.

  • Production LLM behavior

    Posting: LLM API work includes structured outputs, streaming, function calling, error handling and cost optimization. Revision exercise (suggestion): Trace a failed tool-call response through an agent and explain how to validate the output, recover and account for cost.

  • Retrieval and memory design

    Posting: RAG design requires chunking, re-ranking, hybrid search, vector stores and relevance tuning; the role also builds long-term memory services. Revision exercise (suggestion): Compare semantic and hybrid retrieval for a troubleshooting query, then explain what information belongs in retrieval versus persistent agent memory.

  • Evaluation of non-deterministic agents

    Posting: The role defines metrics and test harnesses and runs offline evaluations and A/B tests, including LLM-as-judge approaches. Revision exercise (suggestion): Specify a test set and metrics for tool-choice accuracy and troubleshooting quality, and explain how you would compare two skill configurations.

  • Applied statistics and ML judgment

    Posting: Required foundations include methods such as anomaly detection, time-series analysis, clustering and causal inference, plus judgment about retrieval versus fine-tuning. Revision exercise (suggestion): Given a hypothetical series of network alerts, choose an analysis method, state its assumptions and explain what evidence would change your choice.

Skills to revise

  • Implement a LangGraph workflow

    Posting: Production agent-framework experience is required, and LangGraph is strongly preferred. Revision exercise (suggestion): Build a small graph that selects between mock diagnostic tools, handles a failed call and records why it stopped.

  • Build a Python tool service

    Posting: The role requires production Python and backend API development and includes MCP servers, domain-specific tools and SKILL.md playbooks. Revision exercise (suggestion): Implement a mock troubleshooting tool with a defined schema, API error handling, tests and a short SKILL.md describing its use.

  • Tune a small RAG pipeline

    Posting: RAG pipelines, vector-store-backed search, hybrid retrieval and re-ranking are named responsibilities. Revision exercise (suggestion): Index a small set of sample troubleshooting notes, test several queries, and compare retrieved results before and after a chunking or ranking change.

  • Run a reproducible agent evaluation

    Posting: The role builds test harnesses and A/B tests for skills and tool configurations. Revision exercise (suggestion): Create cases with expected tool choices, run two workflow variants, and report failure categories alongside the metric totals.

  • Deploy and observe a containerized service

    Posting: Docker image management, Kubernetes workloads, CI/CD, health probes, tracing, logging, cost tracking and performance monitoring are specified. Revision exercise (suggestion): Containerize a small Python service, define its Kubernetes Deployment and health probe, and outline automated tests and the traces and metrics needed to diagnose a slow agent run.

  • Transform diagnostic data safely

    Posting: The role develops aggregation and visualization logic for sandboxed execution and works with network engineers on troubleshooting procedures. Revision exercise (suggestion): Using synthetic diagnostic records, write a bounded Python transformation that summarizes anomalies and produces a simple visualization; note what you would confirm with a domain expert. Networking knowledge is a plus, not a requirement.

04

Your preparation checklist

  • Build a requirements evidence sheet

    Map the posting’s degree, production ML/AI and LLM experience, Python, agent frameworks, MCP or equivalent protocols, Kubernetes, and CI/CD requirements to specific evidence you can discuss. Mark gaps rather than inventing examples.

  • Rehearse a production-agent walkthrough

    Prepare a concise account of one relevant system, if you have one: your decisions, ReACT or other orchestration pattern, tool selection, failure handling, deployment, and measured outcomes. LangGraph is strongly preferred, but the posting also names other frameworks.

  • Sketch a Marvis-style troubleshooting workflow

    As an interview exercise, draw a hypothetical path from a network-operations question through reasoning, tool calls, self-correction, and an answer. Explain where a network engineer’s playbook becomes a skill; do not present the sketch as Marvis’s actual design.

  • Draft a tool-serving contract

    Prepare a sample MCP or comparable tool schema and a short skill playbook for a hypothetical diagnostic tool. Specify inputs, outputs, validation, errors, and how you would version, deploy, and monitor the server.

  • Compare retrieval and analysis choices

    Make a one-page design trade-off: chunking, semantic versus hybrid search, re-ranking, and relevance checks for troubleshooting material. Include when statistical or time-series analysis would be more useful than retrieval; discuss agent memory or sandboxed execution as extensions, not assumed features.

  • Prepare an agent evaluation plan

    Define an offline test set, quality and failure metrics, a repeatable harness, and an A/B comparison of skills or tool configurations. Explain how you would handle non-deterministic results and review any LLM-as-judge scores.

  • Outline the production operating model

    Draw a deployment path covering a Python backend API, Docker images, a registry, CI/CD, Kubernetes health probes, and rollback. Add an example trace showing logging, latency, errors, and LLM cost—the posting calls for observable production systems.

  • Write questions for the team

    Prepare questions about how network engineers and product managers turn troubleshooting procedures into skills, how agent quality is evaluated, and which reliability or cost problems matter most. Ask what team leadership or mentoring this role may involve.

AI-generated from the job information · Prepared Sep 30, 2026 (UTC)Useful preparation, not a guarantee of eligibility or an offer.

Availability last checked: Nov 4, 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in United States of America. Matched to this role, not your profile.

Explore more jobs
Finding similar opportunities…