Senior Associate/Assistant Vice President, Full Stack Agentic AI Engineer

What matters most

• Build dependable agent workflows

  The role owns single- and multi-agent orchestration, tool calling, state, memory, and planning. Prepare to explain production design decisions, including how workflows recover from failed or unexpected tool results.

• Make retrieval and data access trustworthy

  The posting calls for RAG pipelines and integrations with investment, portfolio, market-data, and internal knowledge systems. Focus preparation on ingestion, retrieval quality, current data, access controls, and reusable MCP tool connectors.

• Deliver the product end to end

  Responsibilities span professional front-end workflows, back-end services, streaming and asynchronous interactions, and documented, versioned APIs. Prepare to describe how interface and API choices support users and downstream consumers.

• Operate and improve production AI

  The role emphasizes tracing, monitoring, alerting, evaluation, safe failure, human escalation, and incident response. Prepare concrete examples of testing non-deterministic behaviour and using production signals to improve a system.

Likely challenges to think through

• Balancing autonomy with safe access

  A likely design challenge is giving agents useful access to enterprise systems without permitting overbroad or unreliable actions. Prepare to discuss scoped tool permissions, validation, rate limits, error handling, and escalation when an action is uncertain.

• Keeping answers useful as knowledge changes

  RAG quality may be difficult to sustain when source documents and data pipelines change. Prepare a reasoned approach to ingestion updates, hybrid retrieval, evaluation, and detecting regressions rather than assuming a vector store alone solves freshness or relevance.

• Preserving responsiveness without hiding failures

  Streaming responses and long-running agent tasks can improve the experience while complicating state management, observability, and recovery. Prepare to explain how users would see progress and limitations, and how traces and alerts would expose stalled or failed workflows.

Topics to prepare

• Agent orchestration and state

  The posting calls for single- and multi-agent coordination, tool calling, memory, state management, and planning loops. Suggested revision exercise: diagram a multi-step workflow, then explain how it handles retries, repeated tool calls, and state recovery.

• RAG architecture and data freshness

  The role covers ingestion, chunking, embeddings, vector stores, semantic and hybrid retrieval, and keeping knowledge bases current. Suggested revision exercise: compare two chunking and retrieval designs, including how each handles updated documents and evaluates retrieval quality.

• Secure enterprise tool access

  Agents must interact safely with investment data, portfolio systems, market data APIs, and internal knowledge bases; the role also extends MCP tool connectors. Suggested revision exercise: sketch a connector contract with scoped permissions, rate limits, input validation, and error handling. Use a hypothetical integration, not assumed access to Temasek systems.

• Prompt and LLM evaluation

  The posting specifies dynamic context construction, prompt versioning, automated and human evaluation, and regression tests. Suggested revision exercise: define a small evaluation set and explain how you would decide whether a prompt change improves results without introducing regressions.

• Observability and safe failure

  The role requires agent-action logs, LLM traces, monitoring, alerting, graceful degradation, human escalation, and incident response. Suggested revision exercise: trace a failed agent run on paper, identifying the signals needed to diagnose it and the point at which a user should be escalated to a person.

• Full-stack production architecture

  The posting spans React interfaces, Python or Node.js services, streaming APIs, asynchronous tasks, SQL-backed data access, Docker, Kubernetes, cloud deployment, and CI/CD. Suggested revision exercise: draw an end-to-end architecture and explain its API contracts, live-update path, deployment boundaries, and secrets handling.

Skills to revise

• Build a stateful agent workflow

  Suggested hands-on exercise: use Python and LangGraph to build a small workflow with tool calling, explicit state, and a recoverable tool failure; demonstrate streaming through an Anthropic or OpenAI SDK. These frameworks, SDK APIs, and workflow behaviours are named in the posting.

• Implement and evaluate retrieval

  Suggested hands-on exercise: ingest a small sample document set, generate embeddings, index it in pgvector, and compare semantic with hybrid retrieval on a fixed set of questions. Document chunking choices and retrieval errors; the posting explicitly calls for these RAG components.

• Write a guarded tool connector

  Suggested hands-on exercise: implement a mock MCP tool connector with scoped access, input validation, rate limiting, and structured errors. Document its interface. This practices the reusable, well-documented connectors and safe enterprise integrations described in the posting.

• Ship a streaming full-stack interaction

  Suggested hands-on exercise: connect a React interface to a FastAPI service that streams responses and reports progress for an asynchronous task. Specify a versioned API contract and handle interruption in the UI; these patterns appear in the full-stack responsibilities.

• Test and instrument an agent service

  Suggested hands-on exercise: add unit tests for deterministic code, a small LLM evaluation and prompt-regression suite, structured agent-action logs, and traces for latency, token use, and model version. Package the service with Docker and outline a CI/CD check. The posting requires testing, observability, and production delivery rather than a notebook-only demonstration.

• Map the stated requirements to evidence

  Prepare a one-page evidence sheet for the posted 5–8 years of engineering experience, 2+ years in AI/ML, production LLM delivery, and relevant frameworks and languages. Mark gaps rather than implying experience you cannot substantiate.

• Rehearse a production product walkthrough

  Choose a deployed LLM product you worked on, if available. Prepare a concise account of your ownership, users, architecture, deployment, monitoring, incidents, and improvements; distinguish your contributions from the team's.

• Sketch a secure agent workflow

  As interview practice, draw a single- or multi-agent workflow with tool calls, state, and an enterprise-data connector. Explain access-scoped permissions, rate limits, error handling, and how a reusable MCP connector would be documented.

• Prepare a RAG design exercise

  Draft a hypothetical pipeline covering ingestion, chunking, embeddings, vector storage, semantic or hybrid retrieval, and knowledge-base updates. Identify how you would evaluate retrieval quality and manage prompt and context changes.

• Outline an end-to-end user interaction

  Sketch a professional React interface, a Python or Node.js service, and versioned REST and streaming API contracts. Show how streaming responses, long-running tasks, and live updates would behave when a task fails.

• Show how you would test and operate it

  Prepare examples of deterministic tests, LLM evaluation and prompt regression checks, agent-action traces, latency and token-usage monitoring, alerts, safe failure, and human escalation. Use actual results only where you have them.

• Review deployment and data-access decisions

  Prepare a short technical explanation of container deployment, CI/CD, secrets handling, SQL or pipeline-backed data access, and input and output safeguards. Tie each choice to a specific reliability or security concern.

• Write questions for the hiring team

  Bring questions about the investment and operations workflows this role supports, how tool access is governed, how agent quality and incidents are assessed, and which parts of the existing MCP ecosystem need extension.