New opportunity

AI Agent Engineer Intern

AryaXAI · Mumbai, India

About this role

AryaXAI is hiring an AI Agent Engineer Intern for a remote, part-time role listed in Mumbai, India. The description introduces Lexsi Labs as a lab working on aligned, interpretable and safe AI systems. The intern will tackle agentic AI problems across applied, research and product work, with outcomes ranging from prototypes and internal tools to production-grade components, benchmarks or research contributions.

Responsibilities and potential tracks:

Applied Agentic AI: Build agents for enterprise workflows that reason over processes, use tools and data systems, execute multi-step tasks and evaluate outcomes. Possible projects include agents over structured or proprietary data, human-in-the-loop systems and decision-support agents.
Agent R&D and Evaluation: Explore agent architectures, harness design, long-horizon reasoning, alignment and interpretability. Build evaluation frameworks or benchmarks, investigate failure modes, assess tool use and planning, and contribute to papers, technical reports or reusable research infrastructure.
Product and Tooling Agents: Develop tools that help researchers, engineers and users interact with Lexsi systems. Examples include an AlignTune Agent for alignment workflows, AI Scientist-style agents for hypothesis generation and experiment execution, and tools for evaluating or debugging agents.
Across tracks, turn open-ended ideas into working experiments, research artifacts or product capabilities; test planning and memory approaches, document findings and collaborate with research, engineering and product teams.

Requirements

Strong programming skills, preferably in Python; hands-on experience with LLMs or AI systems; and strong interest in agents, evaluation, alignment, interpretability or enterprise AI. Candidates should be able to prototype quickly, read technical papers, communicate findings clearly, work through ambiguity and identify valuable directions independently. Bonus experience includes agent frameworks, long-horizon agents, evaluation pipelines, research projects, open-source tools, backend systems, enterprise data, AI safety or interpretability. No minimum years of experience or compensation are specified.

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

Skills for this role

PythonLLMsAI agentsAgent frameworksAgent evaluationAgent harness designTool usePlanning architecturesMemory architecturesAlignmentInterpretabilityAI safetyPrototypingResearchTechnical documentationBackend systemsEnterprise data

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 useful enterprise agents
Source-backed: The applied track covers agents that reason over workflows, use tools and data systems, and execute multi-step tasks, potentially with human oversight. Preparation: Be ready to explain how you would design and test such a workflow.
Make evaluation central to development
Source-backed: The role includes evaluation frameworks, benchmarks, failure analysis, and assessment of tool use and planning. Preparation: Describe how an experiment would define success, capture failures, and guide iteration.
Experiment with agent architectures
Source-backed: The R&D track explores harnesses, long-horizon reasoning, planning and memory, alignment, and interpretability. Preparation: Review a technical idea you could test, including what evidence would support or challenge it.
Turn research into usable tools
Source-backed: The product track builds tools for researchers, engineers, or users, including agent debugging tools and prototypes that make research capabilities usable. Preparation: Think through the intended user, workflow, and evidence of usefulness.
Deliver clear outputs from ambiguous work
Source-backed: The internship calls for quick prototyping, independent identification of valuable directions, clear documentation, and collaboration across research, engineering, and product. Preparation: Practice framing a bounded experiment and communicating its results and limitations.

Likely challenges to think through

Autonomy versus control
Likely challenge, not a confirmed problem: Multi-step agents acting through tools can be useful but hard to keep reliable and auditable—both stated goals. Prepare to discuss where human review, traceable actions, or stopping conditions would be appropriate.
Measuring long-horizon behavior
Likely challenge, not a confirmed problem: A successful final answer may conceal poor planning or tool use along the way. Prepare to distinguish outcome measures from intermediate failure analysis when proposing an agent evaluation.
Choosing scope across tracks
Likely challenge, not a confirmed problem: Open-ended work could lead toward an applied component, research artifact, or product prototype, each with a different standard of success. Prepare to explain how you would narrow an idea to a testable first milestone and decide what to pursue next.

Practice your answers

Technical practice

How would you design an agent to carry out a multi-step enterprise workflow?

What to coverSuggested preparation: Explain how the agent would represent the task, choose actions, use tools, track progress and determine whether the outcome is correct. Discuss where a simpler workflow would be preferable to a more autonomous agent.

How would you let an agent work with structured or proprietary enterprise data?

What to coverSuggested preparation: Describe how you would make relevant data available to the agent while limiting access and checking the results of tool calls. Address how you would handle missing or inconsistent data rather than letting the agent guess.

How would you test a planning approach for a long-horizon task?

What to coverSuggested preparation: Compare an upfront plan with a plan revised after each step, including the risk of errors accumulating over time. Explain what observations would tell you the approach is helping.

What state or memory would a long-running agent need?

What to coverSuggested preparation: Distinguish task state needed for execution from information worth retaining for later decisions. Discuss how you would check that stored information remains relevant and accurate.

How would you evaluate an agent's tool use and planning?

What to coverSuggested preparation: Define representative tasks, success and failure criteria, and measures that reveal errors within a run rather than only its final answer. Explain how you would compare approaches and use the results to guide changes.

How would you investigate an agent that repeatedly fails a task?

What to coverSuggested preparation: Walk through how you would inspect its actions to separate planning errors, tool failures and incorrect interpretations of results. Describe a focused experiment that could test a proposed fix.

Where would you add human review to a decision-support agent?

What to coverSuggested preparation: Identify decisions or actions that should pause for approval and what evidence a reviewer would need. Relate those choices to the posting's emphasis on controllability, reliability and human-in-the-loop systems.

How would you make an agent's behaviour interpretable and auditable?

What to coverSuggested preparation: Describe what you would record about inputs, tool actions, intermediate decisions and outcomes. Explain the trade-off between useful inspection and adding complexity to an agent prototype.

How would you turn an agent research idea into a useful product prototype?

What to coverSuggested preparation: Define a small experiment that tests the idea, then explain how feedback from researchers, engineers or users would shape a usable workflow. The posting gives evaluation and debugging tools as possible work, not as a required project.

How would you prototype an agent quickly while leaving a path to a reliable component?

What to coverSuggested preparation: Discuss what you would implement and test first using your programming skills, preferably in Python as stated in the posting. Explain which checks, documentation and failure handling you would add before treating the prototype as a dependable component.

Behavioural practice

Tell me about a time you made progress on an ambiguous technical problem.

What to coverSuggested preparation: Use a real situation to explain how you chose a valuable direction, what you tried and what resulted. Make clear which assumptions you tested rather than presenting the initial idea as certain.

Describe a time technical reading changed your implementation or experiment.

What to coverSuggested preparation: Identify the paper or material, the specific idea you applied and the outcome. Explain how you checked whether the idea was useful in your setting.

Tell me about a time you collaborated across different technical or product perspectives.

What to coverSuggested preparation: Describe the shared goal, your actions to resolve differing priorities and the result. Choose an example that shows how you communicated technical trade-offs clearly.

Describe a time an experiment or prototype did not work as expected.

What to coverSuggested preparation: Explain the situation, how you investigated the result and what you documented or changed. Include what the outcome taught you, even if the original approach was abandoned.

Tell me about a time you had to choose between building quickly and testing more thoroughly.

What to coverSuggested preparation: Give a real example of the stakes, the choice you made and its result. Explain how you decided what evidence was sufficient for that stage of the work.

Sharpen your knowledge

Topics to prepare

Agent reasoning and tool use
Posting: Applied agents may reason over workflows, use tools and data systems, and complete multi-step tasks. Suggested revision exercise: draw an agent loop for a three-step workflow, marking where it selects a tool, checks a result, and decides whether to continue.
Agent evaluation and failure modes
Posting: The R&D track includes evaluation frameworks, benchmarks, and analysis of tool use, planning, and failures. Suggested revision exercise: define success and failure criteria for a workflow agent, then classify three hypothetical failures by cause.
Planning and memory architectures
Posting: The role may involve experiments with planning and memory, including long-horizon reasoning. Suggested revision exercise: compare two ways an agent could retain task state across several steps, noting when each might lose context or propagate an error.
Alignment and interpretability
Posting: Alignment, interpretability, transparency, and auditability are stated areas of work. Suggested revision exercise: inspect a hypothetical agent decision and list the evidence, tool actions, and uncertainties a reviewer would need to understand it.
Enterprise workflows and human oversight
Posting: Possible applied work includes agents over structured or proprietary data and human-in-the-loop decision support. Suggested revision exercise: sketch a workflow showing which steps an agent could perform and where a person should review an uncertain or consequential result.

Skills to revise

Prototype an LLM agent in Python
Posting: Strong programming skills, preferably Python, hands-on LLM or AI-system experience, and rapid prototyping are requested. Suggested exercise: build a small agent that chooses between two defined actions for a multi-step task; record its inputs, actions, and final result.
Build a repeatable evaluation harness
Posting: Designing evaluations and creating harnesses are potential responsibilities. Suggested exercise: run a small fixed set of tasks through a prototype, record tool-use errors and completion outcomes, and summarize what changed after one revision.
Debug an agent execution trace
Posting: The role includes analyzing failures and may include tools for evaluating or debugging agents. Suggested exercise: review a failed multi-step run, locate the first incorrect decision, propose a change, and test whether that case improves.
Read and document a technical experiment
Posting: The requirements mention reading technical material and documenting findings clearly. Suggested exercise: read one agent-evaluation paper, state its question and measurement approach, then write a brief experiment note separating observations from proposed next steps.

Your preparation checklist

Choose an agent project to walk through
Prepare a concise account of an LLM or AI system you worked on: the problem, your contribution, reasoning loop, tool use, state or memory, and results. The application asks for an end-to-end example; distinguish what you built from what you would design differently.
Show the implementation and trade-offs
Bring a code sample, repository, or architecture sketch that demonstrates programming ability, preferably in Python. Explain key decisions, constraints, and how you moved from an ambiguous idea to a working prototype.
Prepare an evaluation exercise
Sketch a small test set for a multi-step agent task, with success criteria, tool-use or planning checks, and a way to inspect failures. Be ready to explain how results would guide the next iteration; evaluation and harness design are stated areas of work.
Document failure modes and safeguards
Write up one concrete failure you observed—or, if you lack a deployed example, a clearly hypothetical failure in a proposed design. Cover detection, mitigation, and any human review or audit trail needed for reliable use.
Summarize a relevant technical paper
Choose a paper on agents, evaluation, alignment, or interpretability. Prepare a short summary of its method, limitations, and one testable idea it suggests; the role calls for reading technical material and documenting findings.
Draft accurate application responses
Prepare brief answers to the form’s questions about frameworks, evaluation harnesses, long-running state, failures, and open-source agents. Label learning projects and prototypes as such rather than implying production use.
Ask how the internship work is scoped
Prepare questions about which of the applied, R&D, or product-tooling tracks needs help first; what a useful intern deliverable would look like; and how the remote, part-time work is coordinated across teams.

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…