New opportunity

Manager - Systems Software AI

Clarus Advisers · Pune, India

About this role

Lead the development of an efficient on-device AI software stack for a research-led organization working across software, AI, and hardware. The role focuses on high-performance local inference and agentic workloads, with low latency, efficient memory use, scalable infrastructure, and practical deployment on resource-constrained platforms. The goal is a streamlined out-of-box experience for developers and end users.

Responsibilities

  • Lead and grow the team building the on-device AI inference platform, taking responsibility for execution, technical direction, delivery quality, and roadmap alignment.
  • Shape the architecture and evolution of inference runtimes and execution stacks across Llama.cpp, vLLM, PyTorch, WinML, DXCGC, and TensorRT-RTX. Supported workloads include LLMs, vision-language models, text-to-speech, automatic speech recognition, and diffusion models.
  • Coordinate end-to-end optimization of AI models, data pipelines, and inference runtimes for current and next-generation GPU architectures.
  • Align strategy with software, research, architecture, and product teams, industry partners, and open-source communities. Mentor engineers and develop technical leaders.

Requirements

  • 12+ years of overall industry experience and 2+ years of engineering leadership experience, plus a Bachelor’s, Master’s, or PhD in Computer Science, Software Engineering, Mathematics, or a related field.
  • Proven leadership of high-performing engineering teams in systems software, AI infrastructure, inference runtimes, or related domains.
  • Strong C++ development, debugging, data structures, algorithms, and machine learning systems skills; extensive experience with AI inference pipelines and deep learning frameworks such as Llama.cpp, vLLM, PyTorch, WinML, DXCGC, and TensorRT.

This full-time role is located in Pune, India. Compensation is identified only as a senior management tier; no salary is stated.

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

Skills for this role

C++DebuggingData structuresAlgorithmsMachine learning systemsAI inferenceDeep learningLlama.cppvLLMPyTorchWinMLDXCGCTensorRTTensorRT-RTXGPU architecturesLLMsVision-language modelsText-to-speechAutomatic speech recognitionDiffusion modelsEngineering leadership

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

  • Own platform delivery and team growth

    The manager is accountable for execution, technical direction, delivery quality, and roadmap alignment while growing the on-device AI inference team and developing technical leaders.

  • Set inference-stack architecture

    The role leads the evolution of runtimes and execution stacks across frameworks including Llama.cpp, vLLM, PyTorch, WinML, DXCGC, and TensorRT-RTX, for LLM, vision-language, speech, and diffusion workloads.

  • Optimize across the full inference path

    The posting calls for coordinated optimization of models, data pipelines, and runtimes across current and next-generation GPU architectures, with particular emphasis on low latency and efficient memory use.

  • Make on-device deployment practical

    A stated goal is a streamlined out-of-box experience for developers and end users, including practical local inference and agentic workloads on resource-constrained platforms.

  • Align technical strategy across groups

    The manager works with software, research, architecture, and product teams, as well as industry partners and open-source communities, to shape strategy.

Likely challenges to think through

  • Balance performance against device limits

    Likely preparation challenge, not a confirmed employer problem: lowering latency and memory use may compete with workload capability and ease of deployment. Prepare an example of how you evaluated such trade-offs using measurements and chose a practical design.

  • Avoid fragmenting a broad runtime stack

    Likely preparation challenge: the listed frameworks and workload types may need different execution paths, making a coherent platform difficult. Prepare to explain how you would decide what to share, what to specialize, and how to validate performance and correctness.

  • Turn research and partner input into a deliverable roadmap

    Likely preparation challenge: evolving research, product needs, and external ecosystems can pull priorities in different directions. Prepare an example of resolving competing requests while protecting delivery quality and giving engineers clear ownership.

03

Practice your answers

Technical practice

How would you structure an on-device inference stack that can evolve across multiple runtimes?

What to coverThe posting names Llama.cpp, vLLM, PyTorch, WinML, DXCGC, and TensorRT-RTX as relevant frameworks or execution stacks. Suggested preparation: discuss how you would define interfaces, choose where runtime-specific code belongs, and weigh portability against performance.

How would you investigate high latency in local inference?

What to coverLow latency is an explicit goal. Suggested preparation: explain how you would measure the workload, isolate model, data-pipeline, and runtime costs, then verify that an optimization improves end-to-end latency rather than only one component.

How would you reduce memory use on a resource-constrained device?

What to coverThe role emphasizes efficient memory use and practical deployment on constrained platforms. Suggested preparation: discuss model representation, intermediate buffers, and execution scheduling, including possible effects on latency and output quality.

How would you debug a C++ inference-runtime failure?

What to coverThe posting explicitly calls for strong C++ development and debugging skills. Suggested preparation: walk through a reproducible failure, how you would narrow its cause, and how data structures or algorithms could affect correctness and performance.

How would you approach optimization across current and next-generation GPU architectures?

What to coverThe role coordinates performance work across GPU generations. Suggested preparation: explain how you would establish baselines, identify architecture-sensitive bottlenecks, and balance targeted optimizations with a maintainable execution stack.

How would you coordinate model, data-pipeline, and runtime optimization?

What to coverEnd-to-end optimization across all three is a stated responsibility. Suggested preparation: describe how you would identify the limiting stage, assign work across specialties, and assess whether a local improvement benefits the complete inference path.

How would your evaluation approach differ across the advertised model workloads?

What to coverThe posting spans LLMs, vision-language models, text-to-speech, automatic speech recognition, and diffusion models. Suggested preparation: compare the workloads’ input and output patterns and explain why their performance and quality checks may need to differ.

What changes when local inference supports agentic workloads?

What to coverAgentic workloads are explicitly part of the role’s focus. Suggested preparation: consider repeated inference calls, state and resource management, and how those demands could affect latency and memory priorities; treat these as design considerations, not stated implementation requirements.

How would you make an on-device AI stack practical to deploy and use?

What to coverThe posting calls for practical deployment and a streamlined out-of-box experience for developers and end users. Suggested preparation: explain how you would evaluate setup friction, runtime compatibility, performance, and reliability without assuming a particular distribution method.

How would you detect quality regressions as an inference stack evolves?

What to coverDelivery quality and runtime evolution are stated responsibilities. Suggested preparation: describe representative workload tests, correctness checks, and performance baselines, including how you would distinguish a genuine regression from measurement variation.

Behavioural practice

Tell me about a time you led a systems or AI infrastructure team through a difficult delivery.

What to coverSuggested practice: use a real example to set out the situation, your actions on technical direction and execution, and the result. Explain how you handled delivery quality and competing roadmap priorities.

Describe a time you aligned teams with different technical priorities.

What to coverThe role works with software, research, architecture, and product teams. Suggested practice: give the situation, the actions you took to resolve trade-offs, and the result, making your own contribution clear.

Tell me about a time you developed an engineer or emerging technical leader.

What to coverMentoring engineers and developing technical leaders are stated duties. Suggested practice: describe the person’s development need, your specific coaching or delegation actions, and an observable result without overstating your role.

Describe a time you worked with an external technical partner or open-source community.

What to coverThe posting includes industry partners and open-source communities in its alignment responsibilities. Suggested practice: explain the situation, how you coordinated expectations or technical decisions, and the result; choose an actual example rather than implying that this role uses a particular collaboration process.

Tell me about a time you addressed a recurring engineering-quality problem.

What to coverThe role calls for delivery quality and a culture of operational excellence. Suggested practice: present the situation, the actions you took with the team, and the result, including how you checked whether the improvement lasted.

02

Sharpen your knowledge

Topics to prepare

  • On-device inference trade-offs

    Posting focus: low latency, efficient memory use, resource-constrained deployment, agentic workloads, and a streamlined out-of-box experience. Revision exercise: sketch how you would prioritize latency, memory, deployment simplicity, and output quality for a local agentic workload; explain the trade-offs.

  • Inference runtime architecture

    Posting names Llama.cpp, vLLM, PyTorch, WinML, DXCGC, and TensorRT-RTX as relevant execution stacks. Revision exercise: map where model execution, runtime scheduling, and platform integration sit in an inference stack, then explain what would influence runtime selection. A single stack using every named framework is not stated.

  • Workload-specific inference needs

    Posting spans LLMs, vision-language models, text-to-speech, automatic speech recognition, and diffusion models. Revision exercise: contrast the latency and memory considerations of two of these workloads and identify which parts of their inference pipelines you would examine first.

  • End-to-end GPU optimization

    Posting calls for coordinating optimization of models, data pipelines, and inference runtimes across current and next-generation GPU architectures. Revision exercise: trace a hypothetical inference request end to end and identify where time and memory could be spent. This diagnostic walkthrough is a preparation suggestion, not a stated interview task.

  • Technical direction and team leadership

    Posting assigns the manager responsibility for team growth, execution, delivery quality, roadmap alignment, mentoring, and cross-functional coordination. Revision exercise: outline how you would resolve a proposed runtime change that improves performance but delays a product milestone, including who you would consult and how you would communicate the decision.

Skills to revise

  • C++ debugging and algorithmic reasoning

    Strong C++ development, debugging, data structures, and algorithms are explicit requirements. Practice diagnosing a memory-use or latency regression in a small C++ inference-path example; explain the data-structure choice, likely failure points, and how you would verify a fix.

  • Inference-pipeline diagnosis

    Extensive AI inference-pipeline experience is requested. Practice drawing a pipeline for one posted workload, then separate model, data-pipeline, and runtime contributors to latency and memory use. Using measurements to validate hypotheses is a preparation suggestion, not a specified employer process.

  • Runtime evaluation

    The posting names multiple frameworks and execution stacks. Prepare a comparison of two named options for a specific posted workload, covering deployment fit and performance questions you would test; do not assume they support identical platforms or workloads.

  • Roadmap and mentoring discussion

    Leading and growing engineers while aligning a roadmap is explicit. Practice presenting a short technical roadmap with quality checkpoints, ownership decisions, and a plan to develop technical leaders. This presentation is a preparation exercise, not a stated hiring requirement.

04

Your preparation checklist

  • Map your evidence to the stated requirements

    Prepare a one-page summary of relevant industry and engineering leadership experience, education, and work in systems software or AI inference. The posting specifies 12+ years overall and 2+ years in engineering leadership; present facts without implying they guarantee eligibility.

  • Build an on-device inference project walkthrough

    Select a relevant project and prepare a concise account of the workload, platform constraints, architecture decisions, your role, and measured latency, memory, or deployment results. Distinguish your contributions from the team’s.

  • Practice an inference-stack design exercise

    Sketch how you would structure a local inference stack for one advertised workload, such as an LLM or vision-language model. Explain runtime choices, resource-constrained deployment, agentic workload considerations, and trade-offs for developer and end-user experience; treat this as preparation, not a stated interview exercise.

  • Prepare a C++ performance and debugging example

    Bring one example showing how you diagnosed a systems-level inference issue, changed the implementation, and verified the result. Be ready to discuss relevant data structures, algorithms, memory use, and performance measurements.

  • Explain your optimization approach across the stack

    Outline how you would identify bottlenecks across models, data pipelines, and runtimes on current or next-generation GPU architectures. Include which metrics you would collect and how you would validate a proposed improvement.

  • Document leadership and alignment decisions

    Prepare two brief examples: one covering team growth, mentoring, execution, or delivery quality; the other covering alignment with research, software, architecture, product, partners, or open-source communities. State the decision, your contribution, and the outcome.

  • Draft questions about scope and priorities

    Ask which workloads and runtimes are most important first, what deployment constraints define success, how roadmap decisions are made across teams, and what team-building responsibilities the manager would own. The posting does not specify these details.

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

Availability last checked: 5 Nov 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 India. Matched to this role, not your profile.

Explore more jobs
Finding similar opportunities…