New opportunity

Lead Engineer - AI Engineering

GE Vernova · Bangalore, India

About this role

GE Vernova’s AI Foundry seeks a Lead Engineer - AI Engineering to develop AI agents and large-scale AI/ML solutions for products supporting the energy transition. The team also aims to automate prompting and create reusable prompting frameworks across business use cases.

Responsibilities

Design and optimize AI agents using LLMs, reinforcement learning, planning algorithms and decision-making frameworks. Build scalable multi-agent architectures for long-horizon reasoning, autonomous planning, interaction and complex tasks.
Integrate agents with APIs, backend services, databases and enterprise applications. Prototype, deploy and maintain reliable, performant production AI systems, and improve agent behavior through feedback and user interaction.
Evaluate and monitor agent performance, implement safety guardrails and ethical AI practices, and document architectures, workflows and design decisions. Collaborate with research, engineering, product and deployment teams; improve platform tooling and share emerging technical knowledge.
Create and optimize LLM prompts with domain experts and end users to address internal and external needs.

Qualifications and technical requirements:

Master’s degree in Computer Science, AI/ML, Engineering, Mathematics or a related field, with 3+ years of relevant experience. Experience in AI and generative-AI application development and deployment, particularly autonomous agent systems or related AI software engineering, is required.
Experience building generative-AI applications involving agent orchestration, multi-step reasoning, prompt engineering, RAG integration and model selection. Expertise with LLMs and deep learning models, machine learning lifecycle management, data generation, model training and validation, software engineering and system architecture.
Proficiency in Python and/or JavaScript, TypeScript, Node.js, Java or Go; familiarity with tools and concepts including LangChain, OpenAI APIs, PyTorch, TensorFlow, AutoGenAI, LangGraph, MCP, vector databases, semantic retrieval and real-time data pipelines. Cloud deployment experience with AWS or Google Cloud and Docker or Kubernetes; awareness of AI ethics, data privacy and secure handling of sensitive information. Ability to work independently in a fast-paced experimental environment.

The role requires working from an office in Bangalore and being at least 18 years old. Relocation assistance is provided. Applications must be submitted through GE Vernova’s careers page.

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

Skills for this role

PythonJavaScriptTypeScriptNode.jsJavaGoLangChainOpenAI APIsPyTorchTensorFlowLarge Language ModelsPrompt EngineeringNatural Language ProcessingAutoGenAILangGraphModel Context ProtocolMulti-agent SystemsReinforcement LearningPlanning AlgorithmsVector DatabasesSemantic RetrievalReal-time Data PipelinesAWSGoogle CloudDockerKubernetesModel TrainingFine-tuningModel EvaluationRetrieval-Augmented Generation

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Build capable multi-agent systems
The role centers on designing and optimizing AI agents for long-horizon reasoning, planning, interaction and complex task completion, using LLMs and other decision-making approaches.
Deliver production-ready integrations
The engineer is expected to connect agents to APIs, backend services, databases and enterprise applications, then deploy and maintain systems for reliability and performance.
Evaluate behavior and safeguard use
The posting calls for rigorous agent evaluation, performance monitoring, feedback-driven improvement, safety guardrails, ethical AI practices and secure handling of sensitive information.
Make prompting reusable across use cases
AI Foundry aims to automate prompting and develop frameworks shared across businesses. The role includes optimizing LLM prompts with domain experts and end users for internal and external needs.
Translate research into product systems
The role calls for large-scale AI/ML solutions in global products, collaboration with research, engineering, product and deployment teams, and documentation of architectures and decisions.

Likely challenges to think through

Autonomy versus control
Preparation hypothesis: Longer-running, multi-agent tasks may increase the difficulty of keeping actions predictable and safe. Prepare to explain how you would bound agent actions, evaluate multi-step outcomes and use feedback to improve behavior.
Experimentation versus production reliability
Preparation hypothesis: Rapid agent prototyping may conflict with the performance and maintainability expected of deployed systems. Prepare an example of how you would test an approach, integrate it with services, monitor it and document the resulting design choices.
Shared prompts versus domain-specific needs
Preparation hypothesis: A reusable prompting framework may need to accommodate different users and business contexts without becoming too generic. Prepare to discuss how you would work with domain experts, decide what to standardize and evaluate use-case-specific changes.

Practice your answers

Technical practice

How would you design a multi-agent system for a long-horizon task?

What to coverThe role calls for scalable agents that reason, plan, interact and complete complex tasks. Suggested answer focus: explain how you would divide responsibilities, coordinate agents, track progress and limit unproductive loops.

When would you use planning algorithms or reinforcement learning to improve an agent?

What to coverThe posting names both approaches and calls for improving behavior through feedback and user interaction. Suggested answer focus: compare their purposes, the feedback each needs and how you would check whether behavior actually improved.

How would you integrate an agent with enterprise APIs, services and databases?

What to coverIntegrating these systems is a stated responsibility. Suggested answer focus: describe interface boundaries, authorization, handling failed calls and deciding which actions need human oversight.

How would you build reusable prompting across different use cases?

What to coverThe team aims to automate prompting and share a prompting framework across businesses. Suggested answer focus: distinguish reusable prompt structure from domain-specific content, then explain how you would test changes with domain experts and end users.

How would you design and assess retrieval-augmented generation?

What to coverThe posting names RAG integration, vector databases and semantic retrieval. Suggested answer focus: walk through data preparation, retrieval and response generation, including how you would diagnose poor retrieval versus poor use of retrieved material.

How would you choose a model and decide whether to fine-tune it?

What to coverModel selection, training, fine-tuning and validation appear in the qualifications and skills. Suggested answer focus: compare task fit, quality, latency, data needs and operational cost, and explain what validation would justify a change.

How would you evaluate and monitor an agent after deployment?

What to coverRigorous evaluation, performance monitoring and continuous feedback are explicit responsibilities. Suggested answer focus: define task-success and failure measures, compare against a baseline, and explain how user feedback would inform revisions.

What safety and privacy safeguards would you put around an AI agent?

What to coverThe role calls for safety guardrails, ethical AI practices and secure handling of sensitive information. Suggested answer focus: discuss limits on agent actions, protection of data sent to models or tools, and tests for unsafe behavior.

How would you deploy and maintain a reliable AI application at scale?

What to coverProduction reliability and performance are stated responsibilities; AWS or Google Cloud and Docker or Kubernetes are listed skills. Suggested answer focus: explain deployment, observability, recovery from failures and the trade-off between response time and system capacity.

How would you turn an experimental agent prototype into maintainable software?

What to coverThe posting emphasizes software engineering, system architecture, lifecycle management and documentation of design decisions. Suggested answer focus: cover testable components, validation before release and documentation that helps other teams operate and extend the system.

Behavioural practice

Tell me about working across research, engineering and product to improve a system.

What to coverCollaboration across research, engineering, product and deployment teams is part of the role. Suggested preparation: use a real situation, your specific actions to resolve differing priorities and the resulting decision or outcome.

Describe a time you worked independently in an experimental setting.

What to coverThe posting calls for independent work in a fast-paced experimental environment. Suggested preparation: explain the uncertainty, how you prioritized and tested an approach, and what the results taught you.

Tell me about incorporating domain-expert or end-user feedback.

What to coverThe role involves working with domain experts and end users on LLM solutions. Suggested preparation: give a real example of the initial need, what you changed in response to feedback and the observed result.

Describe how you handled a reliability or performance problem after deployment.

What to coverMaintaining reliable, performant production AI systems is a stated responsibility. Suggested preparation: outline the incident or issue, your diagnostic and coordination actions, and the measurable result or remaining limitation.

Tell me about documenting a design decision or sharing a new technical approach.

What to coverThe posting calls for technical documentation, tooling improvements and knowledge sharing. Suggested preparation: describe the audience and decision, how you communicated trade-offs, and what others were able to do as a result.

Sharpen your knowledge

Topics to prepare

Agent planning and multi-agent architecture
Revision exercise: compare a single-agent design with a multi-agent design for a long-horizon task, explaining planning, decision-making, coordination and where reinforcement learning could improve behavior. The posting explicitly calls for these capabilities.
RAG, semantic retrieval and data flow
Revision exercise: diagram how data moves through a real-time pipeline, vector database and semantic retrieval step into an agent’s answer; identify where retrieval can fail. The posting names RAG integration and these data concepts.
Prompt frameworks and model selection
Revision exercise: outline criteria for choosing an LLM and a reusable prompt structure across two use cases. This relates to the stated goal of automating and reusing prompting, plus the requirement for model selection.
Model lifecycle and agent evaluation
Revision exercise: explain how data generation, training or fine-tuning, validation, user feedback and performance monitoring fit into one lifecycle. The posting calls for these practices and rigorous agent evaluation.
Production architecture, safety and privacy
Revision exercise: review an agent architecture for failure recovery, performance, unsafe actions and sensitive-data exposure. The posting emphasizes reliable production systems, safety guardrails, AI ethics and secure data handling.

Skills to revise

Implement an orchestrated agent
Revision exercise: in Python or another language named in the posting, prototype a multi-step agent flow using a named option such as LangGraph; record its decisions and stopping conditions. This practices the requested agent orchestration and software engineering.
Build and inspect a RAG path
Revision exercise: connect a small document set to semantic retrieval and a vector database, then inspect which retrieved passages support each answer. This practices the posting’s RAG and retrieval requirements.
Iterate on reusable prompts
Revision exercise: create a prompt template, test it on contrasting inputs, and document revisions based on failures. This reflects the responsibility to optimize LLM prompts with domain experts and end users and improve reuse.
Integrate an agent with services
Revision exercise: sketch and prototype an agent call to an API or backend service, including input checks and error handling. The posting explicitly requires integration with APIs, services, databases and enterprise applications.
Evaluate behavior and guardrails
Revision exercise: assemble a small set of multi-step tasks and sensitive-data edge cases; score task completion, inspect failures and test a guardrail. This practices the stated evaluation, monitoring and safety responsibilities.
Package and document a deployment
Revision exercise: containerize a prototype with Docker, describe how it would run on AWS or Google Cloud, and document its architecture and operational checks. The posting names cloud deployment, Docker or Kubernetes, production reliability and technical documentation.

Your preparation checklist

Map the role requirements to evidence
Prepare a one-page reference to relevant experience with autonomous agents, deployed GenAI applications, software architecture, model training and validation, and independent experimentation. Note the posting’s master’s degree and 3+ years of relevant experience without assuming you meet them.
Rehearse an agent project walkthrough
If you have a relevant project, prepare a diagram and five-minute explanation of its goal, agent orchestration, multi-step reasoning, model selection, integrations, your decisions, and measured results. Otherwise, label a proposed example as a design exercise.
Sketch a multi-agent design
Draw a proposed architecture for a long-horizon task, showing planning, agent coordination, API and database access, failure recovery, and when a human would intervene. Explain scalability trade-offs rather than presenting it as a GE Vernova system.
Prepare a reusable prompting example
Draft a sample prompt framework with configurable inputs, a test set, and an iteration log. Show how you would work with domain experts and end users, and where RAG or semantic retrieval would help.
Explain a production deployment path
Prepare a deployment sketch covering service interfaces, a relevant cloud and container approach, monitoring, performance, and maintenance. Distinguish technologies you have used from alternatives you would evaluate.
Build an evaluation and safety plan
Create a small evaluation table for task completion, reasoning errors, latency, and feedback-driven improvements, plus proposed guardrails for privacy, sensitive data, and unsafe agent actions.
Prepare a cross-team decision story
Choose a real example, if available, of working with research, engineering, product, or deployment partners. Be ready to explain a design disagreement, the evidence used, the decision recorded, and what changed afterward.
Write targeted employer questions
Ask how the AI Foundry prioritizes agent use cases for energy-transition products, evaluates production agents, and shares prompting frameworks across businesses. Clarify expectations for Bangalore office work and the role’s technical scope.

Availability last checked: 4 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…