New opportunity

Sr Lead Software Engineer - Agentic AI Solutions

JPMorganChase · Bengaluru, India

About this role

As a Senior Lead Software Engineer at JPMorganChase within Asset and Wealth Management, you will be part of an agile team delivering market-leading, secure, and scalable technology products. You will apply deep technical expertise to solve complex challenges spanning multiple technologies, driving significant business impact through agentic AI solutions.

Responsibilities

  • Works closely with software engineers, product managers, and stakeholders to define requirements and deliver robust solutions.
  • Designs and implements LLM-driven agent services for design, code generation, documentation, test creation, and observability on AWS.
  • Develops orchestration and communication layers between agents using frameworks such as A2A SDK, LangGraph, or AutoGen.
  • Integrates AI agents with toolchains such as Jira, Bitbucket, GitHub, Terraform, and monitoring platforms.
  • Collaborates on system design, SDK development, and data pipelines supporting agent intelligence.
  • Provides technical leadership, mentorship, and guidance to junior engineers and team members.
  • Drives adoption and governance of approved AI-assisted engineering practices across teams to enhance code quality, delivery speed, and operational outcomes.
  • Establishes measurable validation standards including secure coding, peer review, and automated testing while promoting pattern reuse across the SDLC/TLM toolchain.
  • Drives decisions influencing product design, application functionality, and technical operations and processes.

Required qualifications

  • Formal training or certification on software engineering concepts and 5+ years applied experience.
  • Experience in software engineering utilizing AI technologies.
  • Strong hands-on skills in Python, Pydantic, FastAPI, LangGraph, and vector databases for building RAG-based AI agent solutions.
  • Experience integrating multi-agent orchestration frameworks and deploying end-to-end pipelines on AWS (EKS, Lambda, S3, Terraform).
  • Experience with LLM integration, prompt and context engineering, and AI agent frameworks including LangChain, LangGraph, AutoGen, MCPs, and A2A.
  • Solid understanding of CI/CD, Terraform, Kubernetes, Docker, and APIs.
  • Familiarity with observability and monitoring platforms.
  • Demonstrated experience leading effective use of enterprise-authorized AI-assisted software development tools and validating AI outputs for correctness, performance, and security.
  • Strong understanding of responsible AI practices, data sensitivity considerations, and secure handling of inputs and outputs.
  • Ability to tackle design and functionality problems independently with minimal oversight.
  • Practical cloud-native experience.

Preferred qualifications

  • Experience with Azure or Google Cloud Platform (GCP).
  • Familiarity with MLOps practices, including CI/CD for ML, model monitoring, automated deployment, and ML pipelines.

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

Skills for this role

PythonPydanticFastAPILangGraphVector DatabasesRAGAI AgentsAWSEKSAWS LambdaAWS S3TerraformLLMsPrompt EngineeringContext EngineeringLangChainAutoGenModel Context Protocol (MCP)A2A SDKCI/CDKubernetesDockerAPIsJiraBitbucketGitHubObservabilityMLOpsAzureGCP

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

  • Multi-Agent System Architecture and Orchestration

    The core technical mandate is designing and implementing LLM-driven agent services for design, code generation, documentation, and testing on AWS. This requires developing robust orchestration and communication layers using frameworks like LangGraph, AutoGen, or A2A SDK, combined with FastAPI, Pydantic, and vector databases for RAG architectures.

  • Enterprise SDLC Integration and Automation

    A primary deliverable is embedding agentic intelligence directly into enterprise developer toolchains, including Jira, Bitbucket, GitHub, Terraform, and monitoring platforms. The role demands connecting AI agents with CI/CD and deployment infrastructure on AWS (EKS, Lambda, S3) to streamline software development workflows at scale.

  • Responsible AI Governance and Validation Standards

    A critical focus is driving the adoption and governance of approved AI-assisted engineering practices across teams. The engineer must establish measurable validation standards for AI outputs—covering secure coding, automated testing, peer review, data sensitivity, and resilience controls.

  • Technical Leadership and Engineering Enablement

    As a Senior Lead, the position requires mentoring junior engineers, guiding team members, and coaching senior leads on compliant AI usage patterns. Responsibilities include influencing product design, application functionality, and technical operations while fostering reuse of proven automation patterns.

Likely challenges to think through

  • Balancing Developer Velocity with Enterprise Security and Governance

    Integrating LLM agents into internal pipelines risks data leakage, prompt vulnerabilities, or hallucinations reaching production code. Preparing for this trade-off involves defining multi-layered validation guardrails, automated linting, security scans, and clear human-in-the-loop review criteria without creating friction that defeats automation gains.

  • Deterministic Reliability in Multi-Agent Orchestration

    Autonomous agent interactions across frameworks like LangGraph or AutoGen can compound errors, drift in multi-turn state, or generate cyclic loops. Prepare by discussing state machine architectures, fallback logic, deterministic schema validation via Pydantic, and comprehensive telemetry for agent decisions.

  • Scaling Agent Observability Across Heterogeneous Toolchains

    Monitoring autonomous agents interacting with git, issue trackers, and infrastructure tools makes end-to-end tracing and latency tracking challenging. Prepare by showing how to structure distributed tracing across LLM calls, tool execution steps, and standard AWS cloud monitoring platforms.

03

Practice your answers

Technical practice

How would you design a multi-agent orchestration architecture using LangGraph or AutoGen to handle complex SDLC tasks like automated code generation and test creation?

What to coverThe candidate should discuss state management, routing strategies, cyclic recovery, and tool delegation. They should address how intermediate agent states are persisted and validated to avoid infinite loops or drift during multi-step workflows. As a preparation suggestion, highlight the trade-offs between graph-based deterministic flows and dynamic multi-agent conversational patterns.

What architectural patterns and data validation strategies would you use with FastAPI and Pydantic when serving LLM agent services?

What to coverThe response should cover asynchronous endpoint handling, streaming responses (such as SSE) for real-time agent output, and strict input/output schema validation. The candidate should explain how Pydantic models prevent malformed tool inputs and enforce type safety when parsing structured LLM responses. Suggest reviewing latency considerations and error handling for upstream LLM timeouts.

How do you design and optimize an enterprise RAG pipeline using vector databases to provide contextual intelligence to software engineering agents?

What to coverThe candidate should address indexing strategies for source code and technical documentation, embedding model selection, chunking techniques, and metadata filtering. They should discuss hybrid search mechanics and re-ranking to balance retrieval recall against context window limitations. Suggest articulating strategies for refreshing vector embeddings as codebases update incrementally.

How do you securely integrate autonomous AI agents with developer toolchains like GitHub, Bitbucket, Jira, and Terraform?

What to coverThe candidate should explain webhook ingestion, authentication mechanisms (e.g., fine-grained tokens, IAM roles), and sandboxed execution environments. Key trade-offs include granting write or merge permissions versus requiring explicit human-in-the-loop approvals for pull requests and infrastructure deployments. Suggest discussing least-privilege access and blast-radius containment.

How would you deploy and scale an agentic AI service on AWS using EKS, Lambda, S3, and Terraform?

What to coverThe candidate should detail containerizing the agent application with Docker, managing deployment manifests via Terraform, and determining when to use serverless Lambda versus long-running EKS pods. They should address stateless API scaling, storing agent session history or artifacts in S3, and managing AWS IAM permissions securely. Suggest contrasting the cost, cold-start latency, and execution timeouts across compute options.

What validation standards and automated testing frameworks would you institute to evaluate the correctness and security of LLM-generated code?

What to coverThe candidate should detail multi-stage verification pipelines including static analysis (AST parsers, linters), automated unit and integration test generation, and sandboxed test execution. They should address hallucinated dependencies, syntax validity, and automated benchmarking against human-authored baselines. Suggest discussing how to define measurable quality and pass/fail thresholds before code reaches review.

How do you enforce responsible AI practices, data sensitivity boundaries, and prompt injection defenses in enterprise developer agents?

What to coverThe candidate should explain sanitization of prompts and responses to prevent leaking sensitive IP or credentials into external model APIs. They should discuss mitigation strategies for prompt injection, context manipulation, and guardrails enforcing compliant behavior. Suggest outlining role-based access controls and policy enforcement layers embedded within agent middleware.

How do you instrument observability, distributed tracing, and monitoring for multi-turn LLM agent workflows across AWS and enterprise platforms?

What to coverThe candidate should discuss tracing individual LLM calls, tool executions, latency, token consumption, and failure modes across complex agent graphs. They should cover integration with monitoring platforms, custom metrics collection, and alerting for degradation or abnormal token usage. Suggest explaining how distributed trace contexts propagate across asynchronous agent steps.

How do frameworks like Model Context Protocol (MCP) and A2A SDK facilitate standardized tool and agent communication?

What to coverThe candidate should compare standardized agent interfaces and protocols against custom API wrappers for tool exposure and inter-agent communication. They should discuss contract definitions, capability discovery, error handling, and cross-framework interoperability. Suggest demonstrating an understanding of how standard protocols simplify adding new toolchains to existing agents.

Behavioural practice

Describe a situation where you had to drive adoption of AI-assisted engineering practices across resistant or skeptical developer teams.

What to coverThe candidate should use the STAR method to describe how they established trust, demonstrated concrete productivity and code quality gains, and addressed developer concerns regarding reliability. They should highlight leadership tactics, measurable outcomes, and how feedback was gathered to adjust practices. Suggest focusing on balance between engineering freedom and standard compliance.

Tell me about a time you established governance, security, or validation standards for a newly adopted technology stack.

What to coverThe candidate should detail a real-world scenario where they defined validation controls, secure coding policies, or automated review gates for emerging tools. They should explain the actions taken to coach other senior engineers and ensure adherence without severely slowing release cadence. Suggest emphasizing measurable results such as reduced defect rates or compliant audit findings.

Can you share an experience where an autonomous system or automated workflow produced an unexpected failure or severe hallucination in production?

What to coverThe candidate should structure their answer around diagnosing the root cause, mitigating immediate impacts, and redesigning the system to prevent recurrence. They should cover technical adjustments (e.g., tighter schema validation, human approval gates) and stakeholder communication. Suggest demonstrating accountability and systematic post-incident learning.

Describe how you have mentored and upskilled senior engineers and junior team members in complex, evolving technical domains like AI.

What to coverThe candidate should illustrate structured mentorship, code pairing, or workshop initiatives they led to elevate team capability. The narrative should outline how they tailored technical guidance across varying seniority levels and fostered autonomous problem-solving. Suggest highlighting tangible outcomes, such as engineers successfully delivering complex sub-systems independently.

02

Sharpen your knowledge

Topics to prepare

  • Multi-Agent Orchestration and Communication Architectures

    Relevance: Explicitly required to design LLM-driven agent services and develop orchestration layers using frameworks like LangGraph, AutoGen, and A2A SDK. Exercise: Map out an architectural comparison between graph-based state machines (LangGraph) and conversational actor models (AutoGen), focusing on state persistence, cyclic loop mitigation, and dynamic agent delegation.

  • Responsible AI Governance and Verification in SDLC

    Relevance: The posting explicitly mandates driving adoption and governance of AI-assisted engineering, setting validation standards (secure coding, automated testing), and enforcing data sensitivity controls. Exercise: Design an end-to-end policy and verification gate for LLM-generated code, identifying how to screen for sensitive data leakage, hallucinated dependencies, and security vulnerabilities prior to automated CI/CD merges.

  • RAG Architecture and Vector Retrieval Mechanics

    Relevance: Directly lists hands-on skills in vector databases and RAG-based AI agent solutions supporting agent intelligence. Exercise: Review hybrid search mechanics, chunking strategies, metadata filtering, and re-ranking pipelines, analyzing trade-offs between latency, retrieval recall, and context window limits for multi-step agent reasoning.

  • Enterprise Toolchain Integration and Cloud Deployments

    Relevance: Responsibilities include integrating AI agents with toolchains (Jira, Bitbucket, GitHub, Terraform) and deploying scalable pipelines on AWS (EKS, Lambda, S3). Exercise: Diagram a secure architectural flow where an agent listens to webhook events from GitHub or Jira, executes sandboxed code generation tasks, and safely manages cloud credentials via AWS IAM.

Skills to revise

  • Graph-Based State and Agent Workflow Implementation with LangGraph

    Relevance: Explicitly required hands-on skill for orchestrating multi-agent systems and RAG workflows. Exercise: Implement a stateful workflow in Python using LangGraph and Pydantic where an agent dynamically executes a tool, inspects intermediate outputs, and cycles back if validation criteria fail.

  • Asynchronous API Design with FastAPI and Pydantic

    Relevance: Strong hands-on experience in FastAPI and Pydantic is explicitly mandated for building agent backend services. Exercise: Build an asynchronous FastAPI endpoint that streams agent events using SSE (Server-Sent Events) and validates complex input and output payloads using Pydantic v2 schemas.

  • Infrastructure-as-Code Automation with Terraform on AWS

    Relevance: Listed as both a core development skill and an integration toolchain requirement for AWS deployment (EKS, Lambda, S3). Exercise: Write a modular Terraform configuration provisioning an AWS Lambda function with associated IAM execution roles, S3 bucket storage, and environment variables for agent runtime execution.

  • Distributed Tracing and Observability for LLM Applications

    Relevance: Explicitly requires familiarity with observability platforms and implementing agent services for observability. Exercise: Instrument a multi-turn agent interaction to capture detailed span metrics, including prompt token counts, tool execution latency, and error rates, feeding structured logs into a monitoring interface.

04

Your preparation checklist

  • Prepare an end-to-end multi-agent orchestration project walkthrough

    Completion means delivering a concise 5-minute technical walkthrough of an AI agent or multi-agent pipeline built with Python, LangGraph or AutoGen, FastAPI, and Pydantic. Clearly explain the system architecture, state management mechanics, dynamic tool invocation, error recovery loops, and how vector databases were leveraged for contextual retrieval.

  • Draft an enterprise cloud architecture diagram for agentic workflows on AWS

    Completion means sketching a clear design diagram detailing how agent services are hosted and executed on AWS using EKS, Lambda, S3, and Terraform. The deliverable should clearly illustrate ingress API traffic, containerized agent runtimes, secure secrets management, asynchronous event queues, and distributed observability pipelines.

  • Compile structured examples demonstrating AI governance and verification standards

    Completion means articulating two concrete examples demonstrating how you established validation gates for AI-generated code, including automated syntax and lint checks, test suite execution, security scanning, and data sensitivity enforcement. Be prepared to detail how you monitored and coached engineering teams to adopt enterprise-approved AI tools safely.

  • Synthesize a developer toolchain integration case study

    Completion means preparing a concrete explanation of how you integrated autonomous AI capabilities into standard SDLC platforms like GitHub, Bitbucket, Jira, or Terraform CI/CD pipelines. Detail the webhook triggers, authentication boundaries, and the human-in-the-loop review criteria implemented to ensure safe repository merges.

  • Prepare targeted questions exploring JPMC Asset and Wealth Management agent infrastructure

    Completion means formulating 3-4 thoughtful questions regarding their current agentic stack—such as how multi-agent evaluation benchmarks are conducted across asset management workflows, how state isolation is maintained across regulatory boundaries, and how internal SDKs like A2A are standardized across engineering teams.

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

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…