New opportunity

Lead AI Engineer

Money Forward India · Chennai, India

About this role

Money Forward India is hiring a Lead AI Engineer in Chennai to design and drive agentic security workflows across the software development lifecycle, from requirements and threat modeling through secure coding, CI/CD validation, security testing, release assessment, and production feedback. The role combines AI agent engineering, backend and platform work, application security, and cross-team technical leadership.

Responsibilities

Design workflows for SDLC validation, patch management, proactive testing, risk reporting, and release gates. Own a product security context model covering architecture, data sensitivity, authentication and RBAC, credentials and PII, logging, release tiers, and critical product flows.
Define agent decision rules, risk thresholds, human-review requirements, release-blocking criteria, and escalation paths. Implement least-privilege access, prompt-injection defenses, safe tool execution, audit logging, rollback, and kill switches.
Build LLM-based agents using context engineering, tool integrations, orchestration, harness and loop design, and evaluation pipelines. Validate outputs with security experts before trusting rules in production; tune false positives and maintain a rule-change backlog.
Lead application engineers across divisions and translate designs into stack-specific patterns. Partner with SRE/PRE on CI/CD, GitHub and CircleCI workflows, Datadog checks, staging safeguards, and release gates; coordinate with QA, privacy, and security specialists on regression validation, PII handling, secure coding, and release readiness.

Requirements

Bachelor’s degree or higher in Computer Science, Software Engineering, or a related technical field. Strong Python or JavaScript experience building LLM applications and AI agents, including hands-on experience with LLM tooling, frameworks, platforms, RAG, and evaluations.
Understanding of context engineering, instruction design, prompt hardening, tool boundaries, harness and loop engineering, and agent evaluation. Ability to design production-ready workflows with defined inputs, outputs, failure modes, review points, and escalation rules.
Experience with CI/CD, observability, logging, monitoring, and production readiness; ability to lead 3–5 engineers across teams without direct authority; strong problem-solving and communication skills. English proficiency sufficient to read and write technical documentation and collaborate with engineering teams.

Preferred

Experience with LangGraph, LangChain, OpenAI Agents SDK, GitHub, CircleCI, or Datadog; creating reusable engineering standards and materials; application security practices or translating security experts’ knowledge into agent rules; familiarity with Ruby/Rails, Go, Java, React, or Vue; and autonomy in rapid, iterative development. Business-level or higher Japanese is optional.

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

Skills for this role

AI agentsLLMsPythonJavaScriptRAGContext engineeringInstruction designPrompt hardeningAgent evaluationLangGraphLangChainOpenAI Agents SDKCI/CDGitHubCircleCIDatadogObservabilityThreat modelingOWASPSecure codingApplication securityRBACPII handlingRuby on RailsGoJavaReactVueTechnical leadershipEnglish

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

Design security workflows across the SDLC
The role owns agentic workflows spanning threat modeling, secure coding, CI/CD validation, testing, patch management, release gates, and production feedback. Prepare to explain how a workflow moves from a finding to a review, decision, and follow-up.
Make product context usable by agents
The posting assigns ownership of a security context model covering architecture, data sensitivity, authentication and RBAC, credentials and PII, logging, release tiers, and critical flows. Prepare to discuss which context an agent needs for a specific decision and how to keep that context accurate.
Build evaluated agents with explicit safeguards
Responsibilities include LLM orchestration, tool integrations, harnesses, evaluation pipelines, and guardrails such as least privilege, prompt-injection handling, audit logs, rollback, and kill switches. Security experts must validate outputs before rules are trusted in production.
Turn designs into cross-team release practices
The lead works with application engineers across divisions and with SRE/PRE, QA, privacy, and security specialists on stack-specific patterns, CI/CD checks, regression validation, and release readiness. The requirements specify leading 3–5 engineers across teams without direct authority.

Likely challenges to think through

Calibrating release decisions
A likely trade-off is catching meaningful security risks without excessive false positives or unnecessary release blocks. Prepare an example of how to measure rule quality, set review and escalation thresholds with security experts, and use a rule-change backlog to improve decisions.
Balancing agent utility and tool safety
An agent needs enough access to inspect workflows and act on findings, but broader access raises the impact of prompt injection or incorrect actions. Prepare to walk through tool boundaries, least-privilege permissions, auditability, rollback, and when a human must approve an action.
Keeping adoption consistent across teams
A likely difficulty is making shared security rules useful across different product stacks and release workflows without imposing a brittle one-size-fits-all process. Prepare to explain how you would define a common standard, translate it into stack-specific patterns, and resolve disagreements without direct authority.

Practice your answers

Technical practice

How would you design an agentic security workflow across the software development lifecycle?

What to coverSuggested answer focus: Trace inputs and outputs from requirements and threat modeling through secure coding, testing, release assessment, and production feedback. Explain where automation helps, where human review remains necessary, and how failures are escalated.

What would you include in a product security context model?

What to coverSuggested answer focus: Cover architecture, sensitive data, authentication and RBAC, credentials and PII, logging touchpoints, release tiers, and critical product flows. Explain how you would keep that context current and limit what each agent can access.

How would you use RAG and context engineering in a security agent?

What to coverSuggested answer focus: Describe how you would select relevant product context and security guidance while controlling stale or untrusted material. Address what the agent should do when context is missing or conflicting.

How would you structure an agent's tools, orchestration, and execution loop?

What to coverSuggested answer focus: Define the workflow's inputs, outputs, tool boundaries, stopping conditions, and failure paths. Compare a bounded, reviewable sequence with more autonomous execution for security-sensitive work.

How would you defend an agent against prompt injection and unsafe tool use?

What to coverSuggested answer focus: Discuss least-privilege access, separation of untrusted content from instructions, and controls on tool execution. Include audit logging, rollback, and a kill switch for unsafe behavior.

How would you set advisory, review, escalation, and release-blocking rules?

What to coverSuggested answer focus: Explain how risk thresholds and the sensitivity of affected product flows could inform each decision. Make uncertainty visible and identify which decisions need security-expert or other human approval.

How would you evaluate an agent before trusting its security findings in production?

What to coverSuggested answer focus: Describe an evaluation pipeline using representative cases and review by security experts. Explain how you would examine missed risks and false positives, then manage rule changes without weakening release safeguards.

How would you integrate agent findings into CI/CD and release gates?

What to coverSuggested answer focus: Discuss where checks could run in GitHub or CircleCI workflows and how staging safeguards and release decisions would consume their results. Address failed checks, unavailable agents, and routes for human review rather than assuming every finding blocks a release.

How would you translate security expertise into checks for different application stacks?

What to coverSuggested answer focus: Show how a threat-modeling or secure-coding concern could become a reviewable rule or checklist, then be adapted to a team's stack. Explain how you would validate the interpretation with security specialists before reuse.

How would you monitor and improve a deployed security-agent workflow?

What to coverSuggested answer focus: Cover logging, observable outcomes, production feedback, and checks such as those available through Datadog. Explain how signals would feed false-positive tuning, a rule-change backlog, and escalation when the workflow behaves unexpectedly.

Behavioural practice

Tell me about a time you led engineers across teams without direct authority.

What to coverSuggested answer focus: Use a real situation, the actions you took to align ownership and technical decisions, and the result. Make clear how you handled disagreement rather than relying on positional authority.

Describe a time you coordinated a release decision with several specialist teams.

What to coverSuggested answer focus: Use a real example involving relevant partners, such as engineering, SRE, QA, privacy, or security. Explain the situation, how you resolved competing concerns, and what happened.

Tell me about a time expert feedback changed an automation rule or design.

What to coverSuggested answer focus: Describe the initial approach, how you sought and interpreted expert input, and the change you made. State the result and how you checked whether the revised approach worked.

Describe a time you improved a noisy check without overlooking important risks.

What to coverSuggested answer focus: Give a real situation in which false positives affected users or a workflow. Explain your investigation, the trade-off you made, and the observed result.

Tell me about a time you created a reusable technical pattern during rapid development.

What to coverSuggested answer focus: Describe the situation, what you turned into a standard, template, or checklist, and how you helped other teams adopt it. Explain the result without claiming broader adoption than you observed.

Sharpen your knowledge

Topics to prepare

Security context across the SDLC
Suggested exercise: Map a hypothetical product’s architecture, data sensitivity, authentication and RBAC, credentials, PII, logging, release tier, and critical flows to threat-modeling and release-review questions. The posting explicitly assigns ownership of this context model and covers the full SDLC; threat modeling is also listed as preferred knowledge.
Agent context, instructions, and RAG
Suggested exercise: Sketch how an agent would retrieve relevant security context, structure its instructions, and distinguish retrieved evidence from instructions. Context engineering, instruction design, RAG, and LLM-based agents are explicit requirements.
Tool boundaries and agent guardrails
Suggested exercise: For a patch-management agent, identify permitted actions, least-privilege access, prompt-injection risks, audit events, rollback conditions, and a kill-switch trigger. These guardrails and safe tool execution are explicit responsibilities.
Risk decisions and human oversight
Suggested exercise: Draft a decision table distinguishing advisory findings, human review, release blocking, and escalation at different risk thresholds. The role defines these rules and requires clear failure modes and review points.
Evaluation and production feedback
Suggested exercise: Outline how to assess missed findings and false positives, obtain security-expert review before production use, and feed results into a rule-change backlog. Evaluation pipelines, expert validation, and false-positive tuning are stated responsibilities.
CI/CD release readiness and observability
Suggested exercise: Trace where staging safeguards, monitoring signals, and a release gate would sit in a CI/CD flow, including what happens when a check is inconclusive. The posting requires CI/CD and observability experience and names GitHub, CircleCI, and Datadog in the integration work.

Skills to revise

Prototype a bounded agent workflow
Suggested exercise: In Python or JavaScript, implement a small agent flow with defined inputs, outputs, permitted tool calls, a review point, and an escalation outcome. The posting requires strong experience building LLM applications and agents in either language; this prototype is preparation, not a stated hiring task.
Build an agent evaluation set
Suggested exercise: Create example security findings and expected outcomes, then test whether an agent flags risks, avoids false positives, and requests review when uncertain. Hands-on evaluations, evaluation pipelines, and false-positive tuning are specified.
Translate expert guidance into rules
Suggested exercise: Turn a sample secure-coding or PII-handling guideline into an agent rule, a checklist, and cases requiring security-expert confirmation. The role calls for coordination with security and privacy specialists and validation before production trust.
Design a CI/CD integration handoff
Suggested exercise: Write a concise integration plan showing a check’s trigger, evidence, logs, failure behavior, staging validation, and release-gate result. The posting calls for work with SRE/PRE on CI/CD workflows and release gates; GitHub, CircleCI, and Datadog are named platforms.
Lead a cross-team design review
Suggested exercise: Present one agent workflow design with a decision table and stack-specific implementation considerations, then record questions for application engineers, SRE/PRE, QA, privacy, and security. This reflects the stated responsibility to lead 3–5 engineers across teams without direct authority and coordinate with those specialists.

Your preparation checklist

Build a requirements evidence sheet
Prepare a one-page map of the stated requirements to evidence you can discuss: degree, Python or JavaScript agent work, RAG and evaluations, CI/CD and observability, and leading 3–5 engineers without direct authority. Mark gaps rather than implying experience you do not have.
Rehearse an agent project walkthrough
Choose a real project, if available, and explain its context, tool integrations, orchestration, loop design, evaluation results, and failure handling. If using a hypothetical example, label it as a design exercise.
Sketch a product security context model
As a design exercise, produce a sample model covering architecture, data sensitivity, authentication and RBAC, credentials and PII, logging touchpoints, release tiers, and critical flows—the context the role would own.
Diagram an SDLC security workflow
Draw inputs, outputs, and handoffs from requirements and threat modeling through secure coding, CI/CD validation, testing, release assessment, and production feedback. Include patch management and risk reporting, both named in the posting.
Define decisions and safety boundaries
Add example advisory versus release-blocking rules, risk thresholds, human-review points, and escalation paths to the diagram. Show how least privilege, prompt-injection handling, safe tool execution, audit logs, rollback, and a kill switch would work.
Prepare an evaluation and review plan
Draft a small test set and measures for agent quality and false positives. Explain how security experts would review outputs before production rules are trusted, and how findings would enter a rule-change backlog.
Outline release-tool integration
Prepare a sample integration sketch for GitHub or CircleCI workflows, Datadog checks, staging safeguards, and release gates. Show where logging, monitoring, and failure handling support production readiness; do not present the sketch as Money Forward India’s existing setup.
Practice cross-team leadership and questions
Prepare a concise example of aligning engineers across teams without direct authority and turning a design into reusable patterns. Ask the employer how security experts approve rules, who owns release-blocking decisions, and which CI/CD integrations are priorities.

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…