New opportunity

AI Engineer, Agentic Systems

NARIRO · Lucknow, India

About this role

NARIRO is hiring an AI Engineer to build the agent runtime, orchestration and tool-calling layer of its platform, as well as custom AI systems deployed in customer environments. This is a full-time, remote role listed in Lucknow, Uttar Pradesh, India. The engineer will own features from design through production and work closely with a small team in Lucknow.

Responsibilities

Design agent workflows involving triggers, reasoning loops, memory, tool calls and structured outputs.
Integrate models from multiple providers and implement routing based on cost, latency and task.
Build integrations with external systems and tools, including MCP servers.
Add evaluation, logging and guardrails so agent behaviour can be tested and audited in production.
Work with customer engineering teams to scope and deliver custom AI systems.

Requirements

Strong Python or TypeScript skills and solid software engineering fundamentals.
Hands-on experience building applications with large language models, including prompting, tool use, retrieval and evaluation.
Experience designing and consuming APIs and working with databases, queues and background jobs.
Ability to debug non-deterministic systems, write tests, communicate clearly in writing and document decisions. No specific number of years of experience or education requirement is stated.

Preferred

Experience with the Model Context Protocol or similar tool-integration standards; running containerized services on Linux; and an interest in AI security, governance and auditability.

Apply using the form on the page, describing what you have built and linking to code or write-ups if available. The page states that applications close on 6 October 2026.

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

Skills for this role

PythonTypeScriptSoftware engineeringLarge language modelsPromptingTool useRetrievalAI evaluationAPI designDatabasesQueuesBackground jobsTestingDebuggingTechnical documentationModel Context Protocol (MCP)ContainersLinuxAI securityAI governanceAuditability

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 the agent runtime
The role centers on agent workflows with triggers, reasoning loops, memory, tool calls and structured outputs, from design through production.
Route across model providers
NARIRO calls for multi-provider model integration and routing based on cost, latency and task.
Connect agents to external systems
The engineer will build tool and system integrations, including MCP servers. The role also calls for experience with APIs, databases, queues and background jobs.
Make agent behavior testable and auditable
The posting explicitly calls for evaluation, logging and guardrails in production, alongside tests and debugging for non-deterministic systems.
Deliver platform and customer work
The engineer will work on both the core platform and custom systems in customer environments, collaborating with customer engineering teams and documenting decisions.

Likely challenges to think through

Testing variable agent behavior
Preparation hypothesis: model outputs may vary even when the workflow is unchanged, making failures hard to reproduce without overconstraining useful behavior. Prepare to explain how you would combine repeatable test cases, evaluations and logs to investigate failures.
Balancing model-routing objectives
Preparation hypothesis: the lowest-cost or fastest provider may not perform best for every task. Prepare to discuss routing criteria, fallback behavior and how you would measure whether a routing change helps.
Keeping tool integrations dependable
Preparation hypothesis: external tools and customer systems may have different interfaces and failure modes. Prepare to describe how you would handle API errors, retries and structured outputs while keeping tool use observable.
Balancing reusable platform work with custom delivery
Preparation hypothesis: a customer-specific need may not belong in the shared runtime. Prepare to explain how you would scope the requirement with customer engineers, decide what to generalize and document the trade-off.

Practice your answers

Technical practice

Suggested practice: How would you design an agent workflow from trigger to structured output?

What to coverThe role covers triggers, reasoning loops, memory, tool calls and structured outputs. Explain how you would define state, stopping conditions and failure handling, and how you would verify the output contract.

Suggested practice: When would you use retrieval versus agent memory?

What to coverThe posting names both retrieval and memory. Compare what each should retain or fetch, and discuss relevance, freshness and the risk of carrying incorrect context forward.

Suggested practice: How would you integrate an external tool or MCP server?

What to coverExternal integrations are part of the role; MCP experience is preferred, not required. Describe tool contracts, input validation, error handling and how you would test an integration without assuming the tool always succeeds.

Suggested practice: How would you route requests across model providers?

What to coverThe role explicitly calls for routing based on cost, latency and task. Explain how you would compare models for a task, handle provider failures and assess whether a routing change improves the overall system.

Suggested practice: How would you make prompted outputs usable by downstream software?

What to coverThe posting calls for prompting and structured outputs in LLM applications. Discuss output schemas, validation and recovery when a response is incomplete or does not match the expected structure.

Suggested practice: How would you evaluate an agent workflow before and after release?

What to coverThe role calls for evaluation so agent behaviour can be tested in production. Describe representative cases, measures tied to task success and failure, and how you would use results to assess a change.

Suggested practice: How would you debug and test a non-deterministic failure?

What to coverThe posting explicitly seeks comfort debugging non-deterministic systems and writing tests around them. Explain what inputs and intermediate steps you would capture, how you would reproduce the issue, and which checks should be deterministic versus outcome-based.

Suggested practice: What logging and guardrails would you add to an agent runtime?

What to coverThe role calls for logging and guardrails that support production testing and auditability, and lists AI security as an interest. Discuss visibility into model and tool decisions, limits on unsafe actions, and the trade-off between useful records and sensitive data exposure.

Suggested practice: How would you connect an agent feature to APIs and background work?

What to coverThe posting asks for API design and experience with databases, queues and background jobs. Outline request boundaries, persisted state and asynchronous processing, including how you would handle retries and duplicate work.

Suggested practice: How would you prepare a custom AI service for a customer environment?

What to coverThe role includes systems running in customer environments; containers on Linux are listed as preferred experience. Explain what deployment assumptions you would clarify and how you would check configuration, service health and operational constraints without presuming a particular customer setup.

Behavioural practice

Suggested practice: Tell me about a feature you owned from design through production.

What to coverEnd-to-end feature ownership is stated in the posting. Use a real situation, your decisions and actions, and the result; include how you determined the feature was ready to run.

Suggested practice: Describe a time you scoped a technical solution with another engineering team.

What to coverThe role involves scoping and delivering custom AI systems with customer engineering teams. Explain the situation, how you clarified needs and constraints, what you agreed to deliver, and the result.

Suggested practice: Describe a difficult-to-reproduce system failure you investigated.

What to coverDebugging non-deterministic systems is an explicit requirement. Give a real example with the symptoms, the evidence you gathered, the action you took and what changed as a result.

Suggested practice: Tell me about a technical decision you documented for others.

What to coverThe posting emphasizes clear written communication and documenting decisions. Describe the context, alternatives you considered, what you wrote down and how the documentation helped others act or review the outcome.

Suggested practice: Describe how you coordinated delivery in a small team.

What to coverThe role involves working closely with a small team. Use a real situation to explain how you divided or coordinated work, resolved a dependency or disagreement, and what the team delivered.

Sharpen your knowledge

Topics to prepare

Agent workflow design
The role covers triggers, reasoning loops, memory, tool calls and structured outputs. Draw a workflow for a customer task and explain its state transitions, stopping conditions and failure paths.
LLM application trade-offs
The posting requires experience with prompting, tool use, retrieval and evaluation. Compare when a workflow should retrieve information, call a tool or return a structured answer, then identify what you would evaluate for each choice.
Multi-provider model routing
NARIRO calls for routing models by cost, latency and task. Work through three example tasks and justify a routing decision for each, including how you would handle a provider failure.
Production evaluation and auditability
The role includes evaluation, logging and guardrails so agent behaviour can be tested and audited. Sketch what to record for one agent run and how you would use those records to investigate an incorrect result.
Tool-integration boundaries
The role includes external-system integrations; MCP or similar standards are listed as nice to have. Review how a tool’s inputs, outputs and errors should be specified, and explain what an integration standard could add. MCP-specific review is optional preparation, not a core requirement.

Skills to revise

Implement an agent workflow
Using Python or TypeScript, build a small workflow with a trigger, a tool call, a bounded reasoning loop and a validated structured output. This rehearses the posted language requirement and agent-runtime work.
Build and consume an API integration
Create a small API endpoint and a client that calls it as an agent tool; handle invalid inputs, failed calls and response parsing. The posting explicitly asks for API design and consumption and external-tool integrations.
Use databases, queues and background jobs
Prototype a background task that records workflow state in a database and processes queued work; test duplicate and failed-task handling. These components are explicitly named in the requirements.
Test non-deterministic behaviour
Write tests for several plausible model responses, including malformed tool arguments and unexpected outputs; add an evaluation case and logs that make failures diagnosable. This targets the stated testing, debugging, evaluation and logging work.
Implement routing decisions
Write a small routing function that selects among simulated model providers using task, cost and latency inputs, then test its boundary cases. This directly reflects the multi-provider routing responsibility without assuming a particular provider.
Document a customer-facing design
Draft a short design note for a custom AI system in a customer environment: scope, API and data boundaries, test plan, deployment questions and decisions needing customer input. The posting calls for customer-engineering collaboration, end-to-end ownership and clear written documentation; the outline is a preparation exercise, not a stated company process.

Your preparation checklist

Select an end-to-end project walkthrough
The role spans design through production. If you have a relevant LLM application, prepare a concise account of its architecture, your decisions, deployment, failures and what you changed.
Sketch an agent workflow
As a practice exercise, diagram a trigger, reasoning loop, memory, tool calls and structured output. Explain how the workflow handles failed tools and stops safely.
Prepare a model-routing and integration design
The role includes multiple model providers and external tools. Sketch routing by task, cost and latency, plus an API or MCP-style integration; label any design choices as proposals, not NARIRO’s implementation.
Show how you would test uncertain behavior
Prepare an example evaluation plan with test cases, failure analysis, logging and guardrails. Explain how you would debug a non-deterministic result and leave an auditable record.
Gather engineering evidence
Choose code or write-ups, if available, that demonstrate Python or TypeScript, APIs, databases, queues or background jobs. Be ready to explain tests and a documented technical decision; containers, Linux and MCP are listed as nice-to-haves.
Rehearse a customer scoping conversation
The role includes custom systems in customer environments. Practice turning a hypothetical request into written scope, integration assumptions, acceptance checks and open questions.
Write questions for the team
Prepare questions about the boundary between platform and customer work, how agent behavior is evaluated in production, and how the small team collaborates across remote work and Lucknow.
Prepare the application materials
Draft a short account of what you have built and collect code or write-up references if available. The page directs applicants to its form and states that applications close on 6 October 2026.

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…